From ddbdb83c865b1124487b3a00747fc5c1a67e5770 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Fri, 21 Oct 2022 18:56:18 -0700
Subject: [PATCH 01/70] stage 2: Update C types' size/alignment

These updates were made by testing against the `sizeof/_Alignof` reported
by Clang for all supported arch-OS-ABI combinations and correcting any
discrepancies.

This is bound to have a few errors (the recent long double fix for i386
Android is one example), but Clang is certainly not a bad place to start,
especially for our most popular targets.
---
 lib/std/target.zig | 137 +++++++++--------
 src/type.zig       | 363 ++++++++++++++++++++++++++++++++++-----------
 2 files changed, 355 insertions(+), 145 deletions(-)

diff --git a/lib/std/target.zig b/lib/std/target.zig
index d791e3b035..99a137b4b9 100644
--- a/lib/std/target.zig
+++ b/lib/std/target.zig
@@ -1781,68 +1781,89 @@ pub const Target = struct {
     }
 
     pub inline fn longDoubleIs(target: Target, comptime F: type) bool {
-        if (target.abi == .msvc or (target.abi == .android and target.cpu.arch == .i386)) {
-            return F == f64;
-        }
-        return switch (F) {
-            f128 => switch (target.cpu.arch) {
-                .aarch64 => {
-                    // According to Apple's official guide:
-                    // > The long double type is a double precision IEEE754 binary floating-point type,
-                    // > which makes it identical to the double type. This behavior contrasts to the
-                    // > standard specification, in which a long double is a quad-precision, IEEE754
-                    // > binary, floating-point type.
-                    // https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms
-                    return !target.isDarwin();
+        switch (target.os.tag) {
+            .windows, .uefi => switch (target.abi) {
+                .gnu, .gnuilp32, .cygnus => switch (target.cpu.arch) {
+                    .i386 => return F == f80,
+                    .x86_64 => return F == f128,
+                    else => return F == f64,
                 },
-
-                .riscv64,
-                .aarch64_be,
-                .aarch64_32,
-                .s390x,
-                .mips64,
-                .mips64el,
-                .sparc,
-                .sparc64,
-                .sparcel,
-                .powerpc,
-                .powerpcle,
-                .powerpc64,
-                .powerpc64le,
-                .wasm32,
-                .wasm64,
-                => true,
-
-                else => false,
+                else => return F == f64,
             },
-            f80 => switch (target.cpu.arch) {
-                .x86_64, .i386 => true,
-                else => false,
-            },
-            f64 => switch (target.cpu.arch) {
-                .aarch64 => target.isDarwin(),
+            else => {},
+        }
 
-                .x86_64,
-                .i386,
-                .riscv64,
-                .aarch64_be,
-                .aarch64_32,
-                .s390x,
-                .mips64,
-                .mips64el,
-                .sparc,
-                .sparc64,
-                .sparcel,
-                .powerpc,
-                .powerpcle,
-                .powerpc64,
-                .powerpc64le,
-                => false,
+        if (target.abi == .android and target.cpu.arch == .i386)
+            return F == f64;
 
-                else => true,
+        switch (target.cpu.arch) {
+            .aarch64,
+            .aarch64_be,
+            .aarch64_32,
+            => switch (target.os.tag) {
+                // According to Apple's official guide:
+                // > The long double type is a double precision IEEE754 binary floating-point type,
+                // > which makes it identical to the double type. This behavior contrasts to the
+                // > standard specification, in which a long double is a quad-precision, IEEE754
+                // > binary, floating-point type.
+                // https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms
+                .ios, .macos, .watchos, .tvos => return F == f64,
+                .windows, .uefi => return F == f64,
+                else => return F == f128,
             },
-            else => false,
-        };
+
+            .i386 => return F == f80,
+            .x86_64 => return F == f80,
+
+            .mips64,
+            .mips64el,
+            => switch (target.os.tag) {
+                .freebsd => return F == f64,
+                else => return F == f128,
+            },
+
+            .powerpc,
+            .powerpcle,
+            => switch (target.abi) {
+                .musl,
+                .musleabi,
+                .musleabihf,
+                .muslx32,
+                => return F == f64,
+                else => switch (target.os.tag) {
+                    .freebsd, .netbsd, .openbsd => return F == f64,
+                    else => return F == f128,
+                },
+            },
+
+            .powerpc64,
+            .powerpc64le,
+            => switch (target.abi) {
+                .musl,
+                .musleabi,
+                .musleabihf,
+                .muslx32,
+                => return F == f64,
+                else => switch (target.os.tag) {
+                    .freebsd, .openbsd => return F == f64,
+                    else => return F == f128,
+                },
+            },
+
+            .riscv32,
+            .riscv64,
+            .s390x,
+            .sparc,
+            .sparc64,
+            .sparcel,
+            .wasm32,
+            .wasm64,
+            => return F == f128,
+
+            .avr, .tce, .tcele => return F == f32,
+
+            else => return F == f64,
+        }
     }
 
     pub inline fn maxIntAlignment(target: Target) u16 {
@@ -1872,7 +1893,7 @@ pub const Target = struct {
             => 8,
 
             .i386 => return switch (target.os.tag) {
-                .windows => 8,
+                .windows, .uefi => 8,
                 else => 4,
             },
 
diff --git a/src/type.zig b/src/type.zig
index a2f0bb9e8f..bcb8969484 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -2892,41 +2892,24 @@ pub const Type = extern union {
             .anyframe_T,
             => return AbiAlignmentAdvanced{ .scalar = @divExact(target.cpu.arch.ptrBitWidth(), 8) },
 
-            .c_short => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.short.sizeInBits(target), 8) },
-            .c_ushort => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.ushort.sizeInBits(target), 8) },
-            .c_int => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.int.sizeInBits(target), 8) },
-            .c_uint => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.uint.sizeInBits(target), 8) },
-            .c_long => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.long.sizeInBits(target), 8) },
-            .c_ulong => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.ulong.sizeInBits(target), 8) },
-            .c_longlong => switch (target.cpu.arch) {
-                .i386 => switch (target.os.tag) {
-                    .windows, .uefi => return AbiAlignmentAdvanced{ .scalar = 8 },
-                    else => return AbiAlignmentAdvanced{ .scalar = 4 },
-                },
-                else => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.longlong.sizeInBits(target), 8) },
-            },
-            .c_ulonglong => switch (target.cpu.arch) {
-                .i386 => switch (target.os.tag) {
-                    .windows, .uefi => return AbiAlignmentAdvanced{ .scalar = 8 },
-                    else => return AbiAlignmentAdvanced{ .scalar = 4 },
-                },
-                else => return AbiAlignmentAdvanced{ .scalar = @divExact(CType.ulonglong.sizeInBits(target), 8) },
-            },
+            .c_short => return AbiAlignmentAdvanced{ .scalar = CType.short.alignment(target) },
+            .c_ushort => return AbiAlignmentAdvanced{ .scalar = CType.ushort.alignment(target) },
+            .c_int => return AbiAlignmentAdvanced{ .scalar = CType.int.alignment(target) },
+            .c_uint => return AbiAlignmentAdvanced{ .scalar = CType.uint.alignment(target) },
+            .c_long => return AbiAlignmentAdvanced{ .scalar = CType.long.alignment(target) },
+            .c_ulong => return AbiAlignmentAdvanced{ .scalar = CType.ulong.alignment(target) },
+            .c_longlong => return AbiAlignmentAdvanced{ .scalar = CType.longlong.alignment(target) },
+            .c_ulonglong => return AbiAlignmentAdvanced{ .scalar = CType.ulonglong.alignment(target) },
+            .c_longdouble => return AbiAlignmentAdvanced{ .scalar = CType.longdouble.alignment(target) },
 
             .f16 => return AbiAlignmentAdvanced{ .scalar = 2 },
-            .f32 => return AbiAlignmentAdvanced{ .scalar = 4 },
-            .f64 => switch (target.cpu.arch) {
-                .i386 => switch (target.os.tag) {
-                    .windows, .uefi => return AbiAlignmentAdvanced{ .scalar = 8 },
-                    else => return AbiAlignmentAdvanced{ .scalar = 4 },
-                },
+            .f32 => return AbiAlignmentAdvanced{ .scalar = CType.float.alignment(target) },
+            .f64 => switch (CType.double.sizeInBits(target)) {
+                64 => return AbiAlignmentAdvanced{ .scalar = CType.double.alignment(target) },
                 else => return AbiAlignmentAdvanced{ .scalar = 8 },
             },
-            .f128 => return AbiAlignmentAdvanced{ .scalar = 16 },
-
-            .f80 => switch (target.cpu.arch) {
-                .i386 => return AbiAlignmentAdvanced{ .scalar = 4 },
-                .x86_64 => return AbiAlignmentAdvanced{ .scalar = 16 },
+            .f80 => switch (CType.longdouble.sizeInBits(target)) {
+                80 => return AbiAlignmentAdvanced{ .scalar = CType.longdouble.alignment(target) },
                 else => {
                     var payload: Payload.Bits = .{
                         .base = .{ .tag = .int_unsigned },
@@ -2936,17 +2919,7 @@ pub const Type = extern union {
                     return AbiAlignmentAdvanced{ .scalar = abiAlignment(u80_ty, target) };
                 },
             },
-            .c_longdouble => switch (CType.longdouble.sizeInBits(target)) {
-                16 => return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f16, target) },
-                32 => return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f32, target) },
-                64 => return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f64, target) },
-                80 => if (target.cpu.arch == .i386 and target.isMinGW())
-                    return AbiAlignmentAdvanced{ .scalar = 4 }
-                else
-                    return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f80, target) },
-                128 => return AbiAlignmentAdvanced{ .scalar = abiAlignment(Type.f128, target) },
-                else => unreachable,
-            },
+            .f128 => return AbiAlignmentAdvanced{ .scalar = 16 },
 
             // TODO revisit this when we have the concept of the error tag type
             .anyerror_void_error_union,
@@ -3411,16 +3384,8 @@ pub const Type = extern union {
             .f32 => return AbiSizeAdvanced{ .scalar = 4 },
             .f64 => return AbiSizeAdvanced{ .scalar = 8 },
             .f128 => return AbiSizeAdvanced{ .scalar = 16 },
-
-            .f80 => switch (target.cpu.arch) {
-                .i386 => switch (target.os.tag) {
-                    .windows => switch (target.abi) {
-                        .msvc => return AbiSizeAdvanced{ .scalar = 16 },
-                        else => return AbiSizeAdvanced{ .scalar = 12 },
-                    },
-                    else => return AbiSizeAdvanced{ .scalar = 12 },
-                },
-                .x86_64 => return AbiSizeAdvanced{ .scalar = 16 },
+            .f80 => switch (CType.longdouble.sizeInBits(target)) {
+                80 => return AbiSizeAdvanced{ .scalar = std.mem.alignForward(10, CType.longdouble.alignment(target)) },
                 else => {
                     var payload: Payload.Bits = .{
                         .base = .{ .tag = .int_unsigned },
@@ -6654,45 +6619,80 @@ pub const CType = enum {
     ulonglong,
     longdouble,
 
+    // We don't have a `c_float`/`c_double` type in Zig, but these
+    // are useful for querying target-correct alignment and checking
+    // whether C's double is f64 or f32
+    float,
+    double,
+
     pub fn sizeInBits(self: CType, target: Target) u16 {
         switch (target.os.tag) {
             .freestanding, .other => switch (target.cpu.arch) {
                 .msp430 => switch (self) {
                     .short, .ushort, .int, .uint => return 16,
-                    .long, .ulong => return 32,
-                    .longlong, .ulonglong, .longdouble => return 64,
+                    .float, .long, .ulong => return 32,
+                    .longlong, .ulonglong, .double, .longdouble => return 64,
                 },
                 .avr => switch (self) {
                     .short, .ushort, .int, .uint => return 16,
-                    .long, .ulong, .longdouble => return 32,
+                    .long, .ulong, .float, .double, .longdouble => return 32,
                     .longlong, .ulonglong => return 64,
                 },
+                .tce, .tcele => switch (self) {
+                    .short, .ushort => return 16,
+                    .int, .uint, .long, .ulong, .longlong, .ulonglong => return 32,
+                    .float, .double, .longdouble => return 32,
+                },
+                .mips64, .mips64el => switch (self) {
+                    .short, .ushort => return 16,
+                    .int, .uint, .float => return 32,
+                    .long, .ulong => return if (target.abi != .gnuabin32) 64 else 32,
+                    .longlong, .ulonglong, .double => return 64,
+                    .longdouble => return 128,
+                },
+                .x86_64 => switch (self) {
+                    .short, .ushort => return 16,
+                    .int, .uint, .float => return 32,
+                    .long, .ulong => switch (target.abi) {
+                        .gnux32, .muslx32 => return 32,
+                        else => return 64,
+                    },
+                    .longlong, .ulonglong, .double => return 64,
+                    .longdouble => return 80,
+                },
                 else => switch (self) {
                     .short, .ushort => return 16,
-                    .int, .uint => return 32,
+                    .int, .uint, .float => return 32,
                     .long, .ulong => return target.cpu.arch.ptrBitWidth(),
-                    .longlong, .ulonglong => return 64,
+                    .longlong, .ulonglong, .double => return 64,
                     .longdouble => switch (target.cpu.arch) {
                         .i386 => switch (target.abi) {
                             .android => return 64,
                             else => return 80,
                         },
-                        .x86_64 => return 80,
 
+                        .powerpc,
+                        .powerpcle,
+                        .powerpc64,
+                        .powerpc64le,
+                        => switch (target.abi) {
+                            .musl,
+                            .musleabi,
+                            .musleabihf,
+                            .muslx32,
+                            => return 64,
+                            else => return 128,
+                        },
+
+                        .riscv32,
                         .riscv64,
                         .aarch64,
                         .aarch64_be,
                         .aarch64_32,
                         .s390x,
-                        .mips64,
-                        .mips64el,
                         .sparc,
                         .sparc64,
                         .sparcel,
-                        .powerpc,
-                        .powerpcle,
-                        .powerpc64,
-                        .powerpc64le,
                         .wasm32,
                         .wasm64,
                         => return 128,
@@ -6716,23 +6716,78 @@ pub const CType = enum {
             .fuchsia,
             .minix,
             => switch (target.cpu.arch) {
+                .msp430 => switch (self) {
+                    .short, .ushort, .int, .uint => return 16,
+                    .long, .ulong, .float => return 32,
+                    .longlong, .ulonglong, .double, .longdouble => return 64,
+                },
                 .avr => switch (self) {
                     .short, .ushort, .int, .uint => return 16,
-                    .long, .ulong, .longdouble => return 32,
+                    .long, .ulong, .float, .double, .longdouble => return 32,
                     .longlong, .ulonglong => return 64,
                 },
+                .tce, .tcele => switch (self) {
+                    .short, .ushort => return 16,
+                    .int, .uint, .long, .ulong, .longlong, .ulonglong => return 32,
+                    .float, .double, .longdouble => return 32,
+                },
+                .mips64, .mips64el => switch (self) {
+                    .short, .ushort => return 16,
+                    .int, .uint, .float => return 32,
+                    .long, .ulong => return if (target.abi != .gnuabin32) 64 else 32,
+                    .longlong, .ulonglong, .double => return 64,
+                    .longdouble => if (target.os.tag == .freebsd) return 64 else return 128,
+                },
+                .x86_64 => switch (self) {
+                    .short, .ushort => return 16,
+                    .int, .uint, .float => return 32,
+                    .long, .ulong => switch (target.abi) {
+                        .gnux32, .muslx32 => return 32,
+                        else => return 64,
+                    },
+                    .longlong, .ulonglong, .double => return 64,
+                    .longdouble => return 80,
+                },
                 else => switch (self) {
                     .short, .ushort => return 16,
-                    .int, .uint => return 32,
+                    .int, .uint, .float => return 32,
                     .long, .ulong => return target.cpu.arch.ptrBitWidth(),
-                    .longlong, .ulonglong => return 64,
+                    .longlong, .ulonglong, .double => return 64,
                     .longdouble => switch (target.cpu.arch) {
                         .i386 => switch (target.abi) {
                             .android => return 64,
                             else => return 80,
                         },
-                        .x86_64 => return 80,
 
+                        .powerpc,
+                        .powerpcle,
+                        => switch (target.abi) {
+                            .musl,
+                            .musleabi,
+                            .musleabihf,
+                            .muslx32,
+                            => return 64,
+                            else => switch (target.os.tag) {
+                                .freebsd, .netbsd, .openbsd => return 64,
+                                else => return 128,
+                            },
+                        },
+
+                        .powerpc64,
+                        .powerpc64le,
+                        => switch (target.abi) {
+                            .musl,
+                            .musleabi,
+                            .musleabihf,
+                            .muslx32,
+                            => return 64,
+                            else => switch (target.os.tag) {
+                                .freebsd, .openbsd => return 64,
+                                else => return 128,
+                            },
+                        },
+
+                        .riscv32,
                         .riscv64,
                         .aarch64,
                         .aarch64_be,
@@ -6743,10 +6798,6 @@ pub const CType = enum {
                         .sparc,
                         .sparc64,
                         .sparcel,
-                        .powerpc,
-                        .powerpcle,
-                        .powerpc64,
-                        .powerpc64le,
                         .wasm32,
                         .wasm64,
                         => return 128,
@@ -6756,37 +6807,65 @@ pub const CType = enum {
                 },
             },
 
-            .windows, .uefi => switch (self) {
-                .short, .ushort => return 16,
-                .int, .uint, .long, .ulong => return 32,
-                .longlong, .ulonglong => return 64,
-                .longdouble => switch (target.cpu.arch) {
-                    .i386 => switch (target.abi) {
-                        .gnu => return 80,
+            .windows, .uefi => switch (target.cpu.arch) {
+                .i386 => switch (self) {
+                    .short, .ushort => return 16,
+                    .int, .uint, .float => return 32,
+                    .long, .ulong => return 32,
+                    .longlong, .ulonglong, .double => return 64,
+                    .longdouble => switch (target.abi) {
+                        .gnu, .gnuilp32, .cygnus => return 80,
                         else => return 64,
                     },
-                    .x86_64 => switch (target.abi) {
-                        .gnu => return 80,
+                },
+                .x86_64 => switch (self) {
+                    .short, .ushort => return 16,
+                    .int, .uint, .float => return 32,
+                    .long, .ulong => switch (target.abi) {
+                        .cygnus => return 64,
+                        else => return 32,
+                    },
+                    .longlong, .ulonglong, .double => return 64,
+                    .longdouble => switch (target.abi) {
+                        .gnu, .gnuilp32, .cygnus => return 128,
                         else => return 64,
                     },
-                    else => return 64,
+                },
+                else => switch (self) {
+                    .short, .ushort => return 16,
+                    .int, .uint, .float => return 32,
+                    .long, .ulong => return 32,
+                    .longlong, .ulonglong, .double => return 64,
+                    .longdouble => return 64,
                 },
             },
 
             .macos, .ios, .tvos, .watchos => switch (self) {
                 .short, .ushort => return 16,
-                .int, .uint => return 32,
-                .long, .ulong, .longlong, .ulonglong => return 64,
+                .int, .uint, .float => return 32,
+                .long, .ulong => switch (target.cpu.arch) {
+                    .i386, .arm, .aarch64_32 => return 32,
+                    .x86_64 => switch (target.abi) {
+                        .gnux32, .muslx32 => return 32,
+                        else => return 64,
+                    },
+                    else => return 64,
+                },
+                .longlong, .ulonglong, .double => return 64,
                 .longdouble => switch (target.cpu.arch) {
-                    .i386, .x86_64 => return 80,
+                    .i386 => switch (target.abi) {
+                        .android => return 64,
+                        else => return 80,
+                    },
+                    .x86_64 => return 80,
                     else => return 64,
                 },
             },
 
             .amdhsa, .amdpal => switch (self) {
                 .short, .ushort => return 16,
-                .int, .uint => return 32,
-                .long, .ulong, .longlong, .ulonglong => return 64,
+                .int, .uint, .float => return 32,
+                .long, .ulong, .longlong, .ulonglong, .double => return 64,
                 .longdouble => return 128,
             },
 
@@ -6814,4 +6893,114 @@ pub const CType = enum {
             => @panic("TODO specify the C integer and float type sizes for this OS"),
         }
     }
+
+    pub fn alignment(self: CType, target: Target) u16 {
+
+        // Overrides for unusual alignments
+        switch (target.cpu.arch) {
+            .avr => switch (self) {
+                .short, .ushort => return 2,
+                else => return 1,
+            },
+            .i386 => switch (target.os.tag) {
+                .windows, .uefi => switch (self) {
+                    .longlong, .ulonglong, .double => return 8,
+                    .longdouble => switch (target.abi) {
+                        .gnu, .gnuilp32, .cygnus => return 4,
+                        else => return 8,
+                    },
+                    else => {},
+                },
+                else => {},
+            },
+            else => {},
+        }
+
+        // Self-aligned, up to a maximum.
+        return @min(
+            std.math.ceilPowerOfTwoAssert(u16, (self.sizeInBits(target) + 7) / 8),
+            switch (target.cpu.arch) {
+                .arm, .armeb, .thumb, .thumbeb => switch (target.os.tag) {
+                    .netbsd => switch (target.abi) {
+                        .gnueabi,
+                        .gnueabihf,
+                        .eabi,
+                        .eabihf,
+                        .android,
+                        .musleabi,
+                        .musleabihf,
+                        => 8,
+
+                        else => @as(u16, 4),
+                    },
+                    .ios, .tvos, .watchos => 4,
+                    else => 8,
+                },
+
+                .msp430,
+                .avr,
+                => 2,
+
+                .arc,
+                .csky,
+                .i386,
+                .xcore,
+                .dxil,
+                .loongarch32,
+                .tce,
+                .tcele,
+                .le32,
+                .amdil,
+                .hsail,
+                .spir,
+                .spirv32,
+                .kalimba,
+                .shave,
+                .renderscript32,
+                .ve,
+                .spu_2,
+                => 4,
+
+                .aarch64_32,
+                .amdgcn,
+                .amdil64,
+                .bpfel,
+                .bpfeb,
+                .hexagon,
+                .hsail64,
+                .loongarch64,
+                .m68k,
+                .mips,
+                .mipsel,
+                .sparc,
+                .sparcel,
+                .sparc64,
+                .lanai,
+                .le64,
+                .nvptx,
+                .nvptx64,
+                .r600,
+                .s390x,
+                .spir64,
+                .spirv64,
+                .renderscript64,
+                => 8,
+
+                .aarch64,
+                .aarch64_be,
+                .mips64,
+                .mips64el,
+                .powerpc,
+                .powerpcle,
+                .powerpc64,
+                .powerpc64le,
+                .riscv32,
+                .riscv64,
+                .x86_64,
+                .wasm32,
+                .wasm64,
+                => 16,
+            },
+        );
+    }
 };

From f0e66ac4d0e6347bf1b5a00b309fafb5da84191b Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Fri, 21 Oct 2022 19:20:58 -0700
Subject: [PATCH 02/70] std.Target: Remove `longDoubleIs`

This function is redundant with CType.sizeInBits(), and until the
previous commit they disagreed about the correct long double type
for several targets. Although they're all synced up now, it's much
simpler just to have a single source of truth.
---
 lib/std/target.zig   | 86 --------------------------------------------
 src/codegen/llvm.zig |  4 +--
 2 files changed, 2 insertions(+), 88 deletions(-)

diff --git a/lib/std/target.zig b/lib/std/target.zig
index 99a137b4b9..7121c1c3e2 100644
--- a/lib/std/target.zig
+++ b/lib/std/target.zig
@@ -1780,92 +1780,6 @@ pub const Target = struct {
         };
     }
 
-    pub inline fn longDoubleIs(target: Target, comptime F: type) bool {
-        switch (target.os.tag) {
-            .windows, .uefi => switch (target.abi) {
-                .gnu, .gnuilp32, .cygnus => switch (target.cpu.arch) {
-                    .i386 => return F == f80,
-                    .x86_64 => return F == f128,
-                    else => return F == f64,
-                },
-                else => return F == f64,
-            },
-            else => {},
-        }
-
-        if (target.abi == .android and target.cpu.arch == .i386)
-            return F == f64;
-
-        switch (target.cpu.arch) {
-            .aarch64,
-            .aarch64_be,
-            .aarch64_32,
-            => switch (target.os.tag) {
-                // According to Apple's official guide:
-                // > The long double type is a double precision IEEE754 binary floating-point type,
-                // > which makes it identical to the double type. This behavior contrasts to the
-                // > standard specification, in which a long double is a quad-precision, IEEE754
-                // > binary, floating-point type.
-                // https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms
-                .ios, .macos, .watchos, .tvos => return F == f64,
-                .windows, .uefi => return F == f64,
-                else => return F == f128,
-            },
-
-            .i386 => return F == f80,
-            .x86_64 => return F == f80,
-
-            .mips64,
-            .mips64el,
-            => switch (target.os.tag) {
-                .freebsd => return F == f64,
-                else => return F == f128,
-            },
-
-            .powerpc,
-            .powerpcle,
-            => switch (target.abi) {
-                .musl,
-                .musleabi,
-                .musleabihf,
-                .muslx32,
-                => return F == f64,
-                else => switch (target.os.tag) {
-                    .freebsd, .netbsd, .openbsd => return F == f64,
-                    else => return F == f128,
-                },
-            },
-
-            .powerpc64,
-            .powerpc64le,
-            => switch (target.abi) {
-                .musl,
-                .musleabi,
-                .musleabihf,
-                .muslx32,
-                => return F == f64,
-                else => switch (target.os.tag) {
-                    .freebsd, .openbsd => return F == f64,
-                    else => return F == f128,
-                },
-            },
-
-            .riscv32,
-            .riscv64,
-            .s390x,
-            .sparc,
-            .sparc64,
-            .sparcel,
-            .wasm32,
-            .wasm64,
-            => return F == f128,
-
-            .avr, .tce, .tcele => return F == f32,
-
-            else => return F == f64,
-        }
-    }
-
     pub inline fn maxIntAlignment(target: Target) u16 {
         return switch (target.cpu.arch) {
             .avr => 1,
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index b0d1588007..68e969f9e7 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -10615,8 +10615,8 @@ fn backendSupportsF128(target: std.Target) bool {
 fn intrinsicsAllowed(scalar_ty: Type, target: std.Target) bool {
     return switch (scalar_ty.tag()) {
         .f16 => backendSupportsF16(target),
-        .f80 => target.longDoubleIs(f80) and backendSupportsF80(target),
-        .f128 => target.longDoubleIs(f128) and backendSupportsF128(target),
+        .f80 => (CType.longdouble.sizeInBits(target) == 80) and backendSupportsF80(target),
+        .f128 => (CType.longdouble.sizeInBits(target) == 128) and backendSupportsF128(target),
         else => true,
     };
 }

From 94945864b9d8ffa7b707432fb877ae42e383db68 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Fri, 21 Oct 2022 20:16:00 -0700
Subject: [PATCH 03/70] Type.zig: Add `nvcl`/`cuda` CType definitions

---
 src/type.zig | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/type.zig b/src/type.zig
index bcb8969484..51b326e18e 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -6862,6 +6862,18 @@ pub const CType = enum {
                 },
             },
 
+            .nvcl, .cuda => switch (self) {
+                .short, .ushort => return 16,
+                .int, .uint, .float => return 32,
+                .long, .ulong => switch (target.cpu.arch) {
+                    .nvptx => return 32,
+                    .nvptx64 => return 64,
+                    else => return 64,
+                },
+                .longlong, .ulonglong, .double => return 64,
+                .longdouble => return 64,
+            },
+
             .amdhsa, .amdpal => switch (self) {
                 .short, .ushort => return 16,
                 .int, .uint, .float => return 32,
@@ -6876,8 +6888,6 @@ pub const CType = enum {
             .rtems,
             .nacl,
             .aix,
-            .cuda,
-            .nvcl,
             .ps4,
             .ps5,
             .elfiamcu,

From c50f33b1118f2e81597bd9ef5976fcb3eb961dee Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Sat, 22 Oct 2022 13:31:09 -0700
Subject: [PATCH 04/70] compiler_rt: Always export "standard" symbol names

The Zig LLVM backend emits calls to softfloat methods with the "standard
compiler-rt" names. Rather than add complexity to the backend and
have to synchronize the naming scheme across all targets, the simplest
fix is just to export these symbols under both the "standard" and the
platform-specific naming convention.
---
 lib/compiler_rt/addtf3.zig      |  9 ++-------
 lib/compiler_rt/ceil.zig        |  6 ++++--
 lib/compiler_rt/cmptf2.zig      | 35 +++++++++------------------------
 lib/compiler_rt/cos.zig         |  6 ++++--
 lib/compiler_rt/divtf3.zig      | 10 +++-------
 lib/compiler_rt/exp.zig         |  6 ++++--
 lib/compiler_rt/exp2.zig        |  6 ++++--
 lib/compiler_rt/extenddftf2.zig |  9 ++-------
 lib/compiler_rt/extendsftf2.zig |  9 ++-------
 lib/compiler_rt/fabs.zig        |  6 ++++--
 lib/compiler_rt/fixtfdi.zig     |  9 ++-------
 lib/compiler_rt/fixtfsi.zig     |  9 ++-------
 lib/compiler_rt/fixunstfdi.zig  |  9 ++-------
 lib/compiler_rt/fixunstfsi.zig  |  9 ++-------
 lib/compiler_rt/floatditf.zig   |  9 ++-------
 lib/compiler_rt/floatsitf.zig   |  9 ++-------
 lib/compiler_rt/floatunditf.zig |  9 ++-------
 lib/compiler_rt/floatunsitf.zig |  9 ++-------
 lib/compiler_rt/floatuntitf.zig |  9 +++++----
 lib/compiler_rt/floor.zig       |  6 ++++--
 lib/compiler_rt/fma.zig         |  6 ++++--
 lib/compiler_rt/fmax.zig        |  6 ++++--
 lib/compiler_rt/fmin.zig        |  6 ++++--
 lib/compiler_rt/fmod.zig        |  6 ++++--
 lib/compiler_rt/getf2.zig       | 17 ++++------------
 lib/compiler_rt/log.zig         |  6 ++++--
 lib/compiler_rt/log10.zig       |  6 ++++--
 lib/compiler_rt/log2.zig        |  6 ++++--
 lib/compiler_rt/multf3.zig      |  9 ++-------
 lib/compiler_rt/round.zig       |  6 ++++--
 lib/compiler_rt/sin.zig         |  6 ++++--
 lib/compiler_rt/sincos.zig      |  6 ++++--
 lib/compiler_rt/sqrt.zig        |  6 ++++--
 lib/compiler_rt/subtf3.zig      |  9 ++-------
 lib/compiler_rt/trunc.zig       |  6 ++++--
 lib/compiler_rt/trunctfdf2.zig  |  9 ++-------
 lib/compiler_rt/trunctfsf2.zig  |  9 ++-------
 lib/compiler_rt/unordtf2.zig    |  9 ++-------
 38 files changed, 125 insertions(+), 198 deletions(-)

diff --git a/lib/compiler_rt/addtf3.zig b/lib/compiler_rt/addtf3.zig
index 2a22493ded..15c450e193 100644
--- a/lib/compiler_rt/addtf3.zig
+++ b/lib/compiler_rt/addtf3.zig
@@ -5,22 +5,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__addkf3, .{ .name = "__addkf3", .linkage = common.linkage });
+        @export(__addtf3, .{ .name = "__addkf3", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_add, .{ .name = "_Qp_add", .linkage = common.linkage });
-    } else {
-        @export(__addtf3, .{ .name = "__addtf3", .linkage = common.linkage });
     }
+    @export(__addtf3, .{ .name = "__addtf3", .linkage = common.linkage });
 }
 
 pub fn __addtf3(a: f128, b: f128) callconv(.C) f128 {
     return addf3(f128, a, b);
 }
 
-fn __addkf3(a: f128, b: f128) callconv(.C) f128 {
-    return addf3(f128, a, b);
-}
-
 fn _Qp_add(c: *f128, a: *f128, b: *f128) callconv(.C) void {
     c.* = addf3(f128, a.*, b.*);
 }
diff --git a/lib/compiler_rt/ceil.zig b/lib/compiler_rt/ceil.zig
index 406f61fbb9..6622546501 100644
--- a/lib/compiler_rt/ceil.zig
+++ b/lib/compiler_rt/ceil.zig
@@ -18,8 +18,10 @@ comptime {
     @export(ceilf, .{ .name = "ceilf", .linkage = common.linkage });
     @export(ceil, .{ .name = "ceil", .linkage = common.linkage });
     @export(__ceilx, .{ .name = "__ceilx", .linkage = common.linkage });
-    const ceilq_sym_name = if (common.want_ppc_abi) "ceilf128" else "ceilq";
-    @export(ceilq, .{ .name = ceilq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(ceilq, .{ .name = "ceilf128", .linkage = common.linkage });
+    }
+    @export(ceilq, .{ .name = "ceilq", .linkage = common.linkage });
     @export(ceill, .{ .name = "ceill", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/cmptf2.zig b/lib/compiler_rt/cmptf2.zig
index 00263f943a..98137e3dfc 100644
--- a/lib/compiler_rt/cmptf2.zig
+++ b/lib/compiler_rt/cmptf2.zig
@@ -7,10 +7,10 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__eqkf2, .{ .name = "__eqkf2", .linkage = common.linkage });
-        @export(__nekf2, .{ .name = "__nekf2", .linkage = common.linkage });
-        @export(__ltkf2, .{ .name = "__ltkf2", .linkage = common.linkage });
-        @export(__lekf2, .{ .name = "__lekf2", .linkage = common.linkage });
+        @export(__eqtf2, .{ .name = "__eqkf2", .linkage = common.linkage });
+        @export(__netf2, .{ .name = "__nekf2", .linkage = common.linkage });
+        @export(__lttf2, .{ .name = "__ltkf2", .linkage = common.linkage });
+        @export(__letf2, .{ .name = "__lekf2", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_cmp, .{ .name = "_Qp_cmp", .linkage = common.linkage });
         @export(_Qp_feq, .{ .name = "_Qp_feq", .linkage = common.linkage });
@@ -19,13 +19,12 @@ comptime {
         @export(_Qp_fle, .{ .name = "_Qp_fle", .linkage = common.linkage });
         @export(_Qp_fgt, .{ .name = "_Qp_fgt", .linkage = common.linkage });
         @export(_Qp_fge, .{ .name = "_Qp_fge", .linkage = common.linkage });
-    } else {
-        @export(__eqtf2, .{ .name = "__eqtf2", .linkage = common.linkage });
-        @export(__netf2, .{ .name = "__netf2", .linkage = common.linkage });
-        @export(__letf2, .{ .name = "__letf2", .linkage = common.linkage });
-        @export(__cmptf2, .{ .name = "__cmptf2", .linkage = common.linkage });
-        @export(__lttf2, .{ .name = "__lttf2", .linkage = common.linkage });
     }
+    @export(__eqtf2, .{ .name = "__eqtf2", .linkage = common.linkage });
+    @export(__netf2, .{ .name = "__netf2", .linkage = common.linkage });
+    @export(__letf2, .{ .name = "__letf2", .linkage = common.linkage });
+    @export(__cmptf2, .{ .name = "__cmptf2", .linkage = common.linkage });
+    @export(__lttf2, .{ .name = "__lttf2", .linkage = common.linkage });
 }
 
 /// "These functions calculate a <=> b. That is, if a is less than b, they return -1;
@@ -64,22 +63,6 @@ fn __lttf2(a: f128, b: f128) callconv(.C) i32 {
     return __cmptf2(a, b);
 }
 
-fn __eqkf2(a: f128, b: f128) callconv(.C) i32 {
-    return __cmptf2(a, b);
-}
-
-fn __nekf2(a: f128, b: f128) callconv(.C) i32 {
-    return __cmptf2(a, b);
-}
-
-fn __ltkf2(a: f128, b: f128) callconv(.C) i32 {
-    return __cmptf2(a, b);
-}
-
-fn __lekf2(a: f128, b: f128) callconv(.C) i32 {
-    return __cmptf2(a, b);
-}
-
 const SparcFCMP = enum(i32) {
     Equal = 0,
     Less = 1,
diff --git a/lib/compiler_rt/cos.zig b/lib/compiler_rt/cos.zig
index 311d927168..664f6550a4 100644
--- a/lib/compiler_rt/cos.zig
+++ b/lib/compiler_rt/cos.zig
@@ -16,8 +16,10 @@ comptime {
     @export(cosf, .{ .name = "cosf", .linkage = common.linkage });
     @export(cos, .{ .name = "cos", .linkage = common.linkage });
     @export(__cosx, .{ .name = "__cosx", .linkage = common.linkage });
-    const cosq_sym_name = if (common.want_ppc_abi) "cosf128" else "cosq";
-    @export(cosq, .{ .name = cosq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(cosq, .{ .name = "cosf128", .linkage = common.linkage });
+    }
+    @export(cosq, .{ .name = "cosq", .linkage = common.linkage });
     @export(cosl, .{ .name = "cosl", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/divtf3.zig b/lib/compiler_rt/divtf3.zig
index b6cabeab91..736068e819 100644
--- a/lib/compiler_rt/divtf3.zig
+++ b/lib/compiler_rt/divtf3.zig
@@ -9,22 +9,18 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__divkf3, .{ .name = "__divkf3", .linkage = common.linkage });
+        // TODO: why did this not error?
+        @export(__divtf3, .{ .name = "__divkf3", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_div, .{ .name = "_Qp_div", .linkage = common.linkage });
-    } else {
-        @export(__divtf3, .{ .name = "__divtf3", .linkage = common.linkage });
     }
+    @export(__divtf3, .{ .name = "__divtf3", .linkage = common.linkage });
 }
 
 pub fn __divtf3(a: f128, b: f128) callconv(.C) f128 {
     return div(a, b);
 }
 
-fn __divkf3(a: f128, b: f128) callconv(.C) f128 {
-    return div(a, b);
-}
-
 fn _Qp_div(c: *f128, a: *const f128, b: *const f128) callconv(.C) void {
     c.* = div(a.*, b.*);
 }
diff --git a/lib/compiler_rt/exp.zig b/lib/compiler_rt/exp.zig
index f34f226be4..7dfac7328c 100644
--- a/lib/compiler_rt/exp.zig
+++ b/lib/compiler_rt/exp.zig
@@ -18,8 +18,10 @@ comptime {
     @export(expf, .{ .name = "expf", .linkage = common.linkage });
     @export(exp, .{ .name = "exp", .linkage = common.linkage });
     @export(__expx, .{ .name = "__expx", .linkage = common.linkage });
-    const expq_sym_name = if (common.want_ppc_abi) "expf128" else "expq";
-    @export(expq, .{ .name = expq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(expq, .{ .name = "expf128", .linkage = common.linkage });
+    }
+    @export(expq, .{ .name = "expq", .linkage = common.linkage });
     @export(expl, .{ .name = "expl", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/exp2.zig b/lib/compiler_rt/exp2.zig
index e89a918501..daca339bae 100644
--- a/lib/compiler_rt/exp2.zig
+++ b/lib/compiler_rt/exp2.zig
@@ -18,8 +18,10 @@ comptime {
     @export(exp2f, .{ .name = "exp2f", .linkage = common.linkage });
     @export(exp2, .{ .name = "exp2", .linkage = common.linkage });
     @export(__exp2x, .{ .name = "__exp2x", .linkage = common.linkage });
-    const exp2q_sym_name = if (common.want_ppc_abi) "exp2f128" else "exp2q";
-    @export(exp2q, .{ .name = exp2q_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(exp2q, .{ .name = "exp2f128", .linkage = common.linkage });
+    }
+    @export(exp2q, .{ .name = "exp2q", .linkage = common.linkage });
     @export(exp2l, .{ .name = "exp2l", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/extenddftf2.zig b/lib/compiler_rt/extenddftf2.zig
index 21e497b3a4..3005987530 100644
--- a/lib/compiler_rt/extenddftf2.zig
+++ b/lib/compiler_rt/extenddftf2.zig
@@ -5,22 +5,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__extenddfkf2, .{ .name = "__extenddfkf2", .linkage = common.linkage });
+        @export(__extenddftf2, .{ .name = "__extenddfkf2", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_dtoq, .{ .name = "_Qp_dtoq", .linkage = common.linkage });
-    } else {
-        @export(__extenddftf2, .{ .name = "__extenddftf2", .linkage = common.linkage });
     }
+    @export(__extenddftf2, .{ .name = "__extenddftf2", .linkage = common.linkage });
 }
 
 pub fn __extenddftf2(a: f64) callconv(.C) f128 {
     return extendf(f128, f64, @bitCast(u64, a));
 }
 
-fn __extenddfkf2(a: f64) callconv(.C) f128 {
-    return extendf(f128, f64, @bitCast(u64, a));
-}
-
 fn _Qp_dtoq(c: *f128, a: f64) callconv(.C) void {
     c.* = extendf(f128, f64, @bitCast(u64, a));
 }
diff --git a/lib/compiler_rt/extendsftf2.zig b/lib/compiler_rt/extendsftf2.zig
index acdc0d586d..68b0747042 100644
--- a/lib/compiler_rt/extendsftf2.zig
+++ b/lib/compiler_rt/extendsftf2.zig
@@ -5,22 +5,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__extendsfkf2, .{ .name = "__extendsfkf2", .linkage = common.linkage });
+        @export(__extendsftf2, .{ .name = "__extendsfkf2", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_stoq, .{ .name = "_Qp_stoq", .linkage = common.linkage });
-    } else {
-        @export(__extendsftf2, .{ .name = "__extendsftf2", .linkage = common.linkage });
     }
+    @export(__extendsftf2, .{ .name = "__extendsftf2", .linkage = common.linkage });
 }
 
 pub fn __extendsftf2(a: f32) callconv(.C) f128 {
     return extendf(f128, f32, @bitCast(u32, a));
 }
 
-fn __extendsfkf2(a: f32) callconv(.C) f128 {
-    return extendf(f128, f32, @bitCast(u32, a));
-}
-
 fn _Qp_stoq(c: *f128, a: f32) callconv(.C) void {
     c.* = extendf(f128, f32, @bitCast(u32, a));
 }
diff --git a/lib/compiler_rt/fabs.zig b/lib/compiler_rt/fabs.zig
index fd3a58a9b7..e9ce98bb7a 100644
--- a/lib/compiler_rt/fabs.zig
+++ b/lib/compiler_rt/fabs.zig
@@ -10,8 +10,10 @@ comptime {
     @export(fabsf, .{ .name = "fabsf", .linkage = common.linkage });
     @export(fabs, .{ .name = "fabs", .linkage = common.linkage });
     @export(__fabsx, .{ .name = "__fabsx", .linkage = common.linkage });
-    const fabsq_sym_name = if (common.want_ppc_abi) "fabsf128" else "fabsq";
-    @export(fabsq, .{ .name = fabsq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(fabsq, .{ .name = "fabsf128", .linkage = common.linkage });
+    }
+    @export(fabsq, .{ .name = "fabsq", .linkage = common.linkage });
     @export(fabsl, .{ .name = "fabsl", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/fixtfdi.zig b/lib/compiler_rt/fixtfdi.zig
index 9cc9835352..f9a32828f1 100644
--- a/lib/compiler_rt/fixtfdi.zig
+++ b/lib/compiler_rt/fixtfdi.zig
@@ -5,22 +5,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__fixkfdi, .{ .name = "__fixkfdi", .linkage = common.linkage });
+        @export(__fixtfdi, .{ .name = "__fixkfdi", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_qtox, .{ .name = "_Qp_qtox", .linkage = common.linkage });
-    } else {
-        @export(__fixtfdi, .{ .name = "__fixtfdi", .linkage = common.linkage });
     }
+    @export(__fixtfdi, .{ .name = "__fixtfdi", .linkage = common.linkage });
 }
 
 pub fn __fixtfdi(a: f128) callconv(.C) i64 {
     return floatToInt(i64, a);
 }
 
-fn __fixkfdi(a: f128) callconv(.C) i64 {
-    return floatToInt(i64, a);
-}
-
 fn _Qp_qtox(a: *const f128) callconv(.C) i64 {
     return floatToInt(i64, a.*);
 }
diff --git a/lib/compiler_rt/fixtfsi.zig b/lib/compiler_rt/fixtfsi.zig
index f46208f02b..0f5e3924ae 100644
--- a/lib/compiler_rt/fixtfsi.zig
+++ b/lib/compiler_rt/fixtfsi.zig
@@ -5,22 +5,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__fixkfsi, .{ .name = "__fixkfsi", .linkage = common.linkage });
+        @export(__fixtfsi, .{ .name = "__fixkfsi", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_qtoi, .{ .name = "_Qp_qtoi", .linkage = common.linkage });
-    } else {
-        @export(__fixtfsi, .{ .name = "__fixtfsi", .linkage = common.linkage });
     }
+    @export(__fixtfsi, .{ .name = "__fixtfsi", .linkage = common.linkage });
 }
 
 pub fn __fixtfsi(a: f128) callconv(.C) i32 {
     return floatToInt(i32, a);
 }
 
-fn __fixkfsi(a: f128) callconv(.C) i32 {
-    return floatToInt(i32, a);
-}
-
 fn _Qp_qtoi(a: *const f128) callconv(.C) i32 {
     return floatToInt(i32, a.*);
 }
diff --git a/lib/compiler_rt/fixunstfdi.zig b/lib/compiler_rt/fixunstfdi.zig
index 0657bf20c1..fb9ff5b330 100644
--- a/lib/compiler_rt/fixunstfdi.zig
+++ b/lib/compiler_rt/fixunstfdi.zig
@@ -5,22 +5,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__fixunskfdi, .{ .name = "__fixunskfdi", .linkage = common.linkage });
+        @export(__fixunstfdi, .{ .name = "__fixunskfdi", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_qtoux, .{ .name = "_Qp_qtoux", .linkage = common.linkage });
-    } else {
-        @export(__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = common.linkage });
     }
+    @export(__fixunstfdi, .{ .name = "__fixunstfdi", .linkage = common.linkage });
 }
 
 pub fn __fixunstfdi(a: f128) callconv(.C) u64 {
     return floatToInt(u64, a);
 }
 
-fn __fixunskfdi(a: f128) callconv(.C) u64 {
-    return floatToInt(u64, a);
-}
-
 fn _Qp_qtoux(a: *const f128) callconv(.C) u64 {
     return floatToInt(u64, a.*);
 }
diff --git a/lib/compiler_rt/fixunstfsi.zig b/lib/compiler_rt/fixunstfsi.zig
index 70725ddf38..79cacbe340 100644
--- a/lib/compiler_rt/fixunstfsi.zig
+++ b/lib/compiler_rt/fixunstfsi.zig
@@ -5,22 +5,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__fixunskfsi, .{ .name = "__fixunskfsi", .linkage = common.linkage });
+        @export(__fixunstfsi, .{ .name = "__fixunskfsi", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_qtoui, .{ .name = "_Qp_qtoui", .linkage = common.linkage });
-    } else {
-        @export(__fixunstfsi, .{ .name = "__fixunstfsi", .linkage = common.linkage });
     }
+    @export(__fixunstfsi, .{ .name = "__fixunstfsi", .linkage = common.linkage });
 }
 
 pub fn __fixunstfsi(a: f128) callconv(.C) u32 {
     return floatToInt(u32, a);
 }
 
-fn __fixunskfsi(a: f128) callconv(.C) u32 {
-    return floatToInt(u32, a);
-}
-
 fn _Qp_qtoui(a: *const f128) callconv(.C) u32 {
     return floatToInt(u32, a.*);
 }
diff --git a/lib/compiler_rt/floatditf.zig b/lib/compiler_rt/floatditf.zig
index 731c6d8d86..1f651b817b 100644
--- a/lib/compiler_rt/floatditf.zig
+++ b/lib/compiler_rt/floatditf.zig
@@ -5,22 +5,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__floatdikf, .{ .name = "__floatdikf", .linkage = common.linkage });
+        @export(__floatditf, .{ .name = "__floatdikf", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_xtoq, .{ .name = "_Qp_xtoq", .linkage = common.linkage });
-    } else {
-        @export(__floatditf, .{ .name = "__floatditf", .linkage = common.linkage });
     }
+    @export(__floatditf, .{ .name = "__floatditf", .linkage = common.linkage });
 }
 
 pub fn __floatditf(a: i64) callconv(.C) f128 {
     return intToFloat(f128, a);
 }
 
-fn __floatdikf(a: i64) callconv(.C) f128 {
-    return intToFloat(f128, a);
-}
-
 fn _Qp_xtoq(c: *f128, a: i64) callconv(.C) void {
     c.* = intToFloat(f128, a);
 }
diff --git a/lib/compiler_rt/floatsitf.zig b/lib/compiler_rt/floatsitf.zig
index 0954199170..20473fa1d0 100644
--- a/lib/compiler_rt/floatsitf.zig
+++ b/lib/compiler_rt/floatsitf.zig
@@ -5,22 +5,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__floatsikf, .{ .name = "__floatsikf", .linkage = common.linkage });
+        @export(__floatsitf, .{ .name = "__floatsikf", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_itoq, .{ .name = "_Qp_itoq", .linkage = common.linkage });
-    } else {
-        @export(__floatsitf, .{ .name = "__floatsitf", .linkage = common.linkage });
     }
+    @export(__floatsitf, .{ .name = "__floatsitf", .linkage = common.linkage });
 }
 
 pub fn __floatsitf(a: i32) callconv(.C) f128 {
     return intToFloat(f128, a);
 }
 
-fn __floatsikf(a: i32) callconv(.C) f128 {
-    return intToFloat(f128, a);
-}
-
 fn _Qp_itoq(c: *f128, a: i32) callconv(.C) void {
     c.* = intToFloat(f128, a);
 }
diff --git a/lib/compiler_rt/floatunditf.zig b/lib/compiler_rt/floatunditf.zig
index 1eda21891d..9236f4705f 100644
--- a/lib/compiler_rt/floatunditf.zig
+++ b/lib/compiler_rt/floatunditf.zig
@@ -5,22 +5,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__floatundikf, .{ .name = "__floatundikf", .linkage = common.linkage });
+        @export(__floatunditf, .{ .name = "__floatundikf", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_uxtoq, .{ .name = "_Qp_uxtoq", .linkage = common.linkage });
-    } else {
-        @export(__floatunditf, .{ .name = "__floatunditf", .linkage = common.linkage });
     }
+    @export(__floatunditf, .{ .name = "__floatunditf", .linkage = common.linkage });
 }
 
 pub fn __floatunditf(a: u64) callconv(.C) f128 {
     return intToFloat(f128, a);
 }
 
-fn __floatundikf(a: u64) callconv(.C) f128 {
-    return intToFloat(f128, a);
-}
-
 fn _Qp_uxtoq(c: *f128, a: u64) callconv(.C) void {
     c.* = intToFloat(f128, a);
 }
diff --git a/lib/compiler_rt/floatunsitf.zig b/lib/compiler_rt/floatunsitf.zig
index bee656c801..af454e1e02 100644
--- a/lib/compiler_rt/floatunsitf.zig
+++ b/lib/compiler_rt/floatunsitf.zig
@@ -5,22 +5,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__floatunsikf, .{ .name = "__floatunsikf", .linkage = common.linkage });
+        @export(__floatunsitf, .{ .name = "__floatunsikf", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_uitoq, .{ .name = "_Qp_uitoq", .linkage = common.linkage });
-    } else {
-        @export(__floatunsitf, .{ .name = "__floatunsitf", .linkage = common.linkage });
     }
+    @export(__floatunsitf, .{ .name = "__floatunsitf", .linkage = common.linkage });
 }
 
 pub fn __floatunsitf(a: u32) callconv(.C) f128 {
     return intToFloat(f128, a);
 }
 
-fn __floatunsikf(a: u32) callconv(.C) f128 {
-    return intToFloat(f128, a);
-}
-
 fn _Qp_uitoq(c: *f128, a: u32) callconv(.C) void {
     c.* = intToFloat(f128, a);
 }
diff --git a/lib/compiler_rt/floatuntitf.zig b/lib/compiler_rt/floatuntitf.zig
index eb5d7037e9..ee386bc96b 100644
--- a/lib/compiler_rt/floatuntitf.zig
+++ b/lib/compiler_rt/floatuntitf.zig
@@ -5,12 +5,13 @@ const intToFloat = @import("./int_to_float.zig").intToFloat;
 pub const panic = common.panic;
 
 comptime {
-    const symbol_name = if (common.want_ppc_abi) "__floatuntikf" else "__floatuntitf";
-
     if (common.want_windows_v2u64_abi) {
-        @export(__floatuntitf_windows_x86_64, .{ .name = symbol_name, .linkage = common.linkage });
+        @export(__floatuntitf_windows_x86_64, .{ .name = "__floatuntitf", .linkage = common.linkage });
     } else {
-        @export(__floatuntitf, .{ .name = symbol_name, .linkage = common.linkage });
+        if (common.want_ppc_abi) {
+            @export(__floatuntitf, .{ .name = "__floatuntikf", .linkage = common.linkage });
+        }
+        @export(__floatuntitf, .{ .name = "__floatuntitf", .linkage = common.linkage });
     }
 }
 
diff --git a/lib/compiler_rt/floor.zig b/lib/compiler_rt/floor.zig
index ef02786eb4..afdc825f9f 100644
--- a/lib/compiler_rt/floor.zig
+++ b/lib/compiler_rt/floor.zig
@@ -18,8 +18,10 @@ comptime {
     @export(floorf, .{ .name = "floorf", .linkage = common.linkage });
     @export(floor, .{ .name = "floor", .linkage = common.linkage });
     @export(__floorx, .{ .name = "__floorx", .linkage = common.linkage });
-    const floorq_sym_name = if (common.want_ppc_abi) "floorf128" else "floorq";
-    @export(floorq, .{ .name = floorq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(floorq, .{ .name = "floorf128", .linkage = common.linkage });
+    }
+    @export(floorq, .{ .name = "floorq", .linkage = common.linkage });
     @export(floorl, .{ .name = "floorl", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/fma.zig b/lib/compiler_rt/fma.zig
index aa37276ac3..4bde30f50f 100644
--- a/lib/compiler_rt/fma.zig
+++ b/lib/compiler_rt/fma.zig
@@ -19,8 +19,10 @@ comptime {
     @export(fmaf, .{ .name = "fmaf", .linkage = common.linkage });
     @export(fma, .{ .name = "fma", .linkage = common.linkage });
     @export(__fmax, .{ .name = "__fmax", .linkage = common.linkage });
-    const fmaq_sym_name = if (common.want_ppc_abi) "fmaf128" else "fmaq";
-    @export(fmaq, .{ .name = fmaq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(fmaq, .{ .name = "fmaf128", .linkage = common.linkage });
+    }
+    @export(fmaq, .{ .name = "fmaq", .linkage = common.linkage });
     @export(fmal, .{ .name = "fmal", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/fmax.zig b/lib/compiler_rt/fmax.zig
index 5fb87e0183..df7c4a7f2e 100644
--- a/lib/compiler_rt/fmax.zig
+++ b/lib/compiler_rt/fmax.zig
@@ -11,8 +11,10 @@ comptime {
     @export(fmaxf, .{ .name = "fmaxf", .linkage = common.linkage });
     @export(fmax, .{ .name = "fmax", .linkage = common.linkage });
     @export(__fmaxx, .{ .name = "__fmaxx", .linkage = common.linkage });
-    const fmaxq_sym_name = if (common.want_ppc_abi) "fmaxf128" else "fmaxq";
-    @export(fmaxq, .{ .name = fmaxq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(fmaxq, .{ .name = "fmaxf128", .linkage = common.linkage });
+    }
+    @export(fmaxq, .{ .name = "fmaxq", .linkage = common.linkage });
     @export(fmaxl, .{ .name = "fmaxl", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/fmin.zig b/lib/compiler_rt/fmin.zig
index cc2fd7b3ac..7565f3a572 100644
--- a/lib/compiler_rt/fmin.zig
+++ b/lib/compiler_rt/fmin.zig
@@ -11,8 +11,10 @@ comptime {
     @export(fminf, .{ .name = "fminf", .linkage = common.linkage });
     @export(fmin, .{ .name = "fmin", .linkage = common.linkage });
     @export(__fminx, .{ .name = "__fminx", .linkage = common.linkage });
-    const fminq_sym_name = if (common.want_ppc_abi) "fminf128" else "fminq";
-    @export(fminq, .{ .name = fminq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(fminq, .{ .name = "fminf128", .linkage = common.linkage });
+    }
+    @export(fminq, .{ .name = "fminq", .linkage = common.linkage });
     @export(fminl, .{ .name = "fminl", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/fmod.zig b/lib/compiler_rt/fmod.zig
index 22b20438cc..e276b99884 100644
--- a/lib/compiler_rt/fmod.zig
+++ b/lib/compiler_rt/fmod.zig
@@ -13,8 +13,10 @@ comptime {
     @export(fmodf, .{ .name = "fmodf", .linkage = common.linkage });
     @export(fmod, .{ .name = "fmod", .linkage = common.linkage });
     @export(__fmodx, .{ .name = "__fmodx", .linkage = common.linkage });
-    const fmodq_sym_name = if (common.want_ppc_abi) "fmodf128" else "fmodq";
-    @export(fmodq, .{ .name = fmodq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(fmodq, .{ .name = "fmodf128", .linkage = common.linkage });
+    }
+    @export(fmodq, .{ .name = "fmodq", .linkage = common.linkage });
     @export(fmodl, .{ .name = "fmodl", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/getf2.zig b/lib/compiler_rt/getf2.zig
index 8d9d39c1f9..831736250f 100644
--- a/lib/compiler_rt/getf2.zig
+++ b/lib/compiler_rt/getf2.zig
@@ -7,15 +7,14 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__gekf2, .{ .name = "__gekf2", .linkage = common.linkage });
-        @export(__gtkf2, .{ .name = "__gtkf2", .linkage = common.linkage });
+        @export(__getf2, .{ .name = "__gekf2", .linkage = common.linkage });
+        @export(__gttf2, .{ .name = "__gtkf2", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         // These exports are handled in cmptf2.zig because gt and ge on sparc
         // are based on calling _Qp_cmp.
-    } else {
-        @export(__getf2, .{ .name = "__getf2", .linkage = common.linkage });
-        @export(__gttf2, .{ .name = "__gttf2", .linkage = common.linkage });
     }
+    @export(__getf2, .{ .name = "__getf2", .linkage = common.linkage });
+    @export(__gttf2, .{ .name = "__gttf2", .linkage = common.linkage });
 }
 
 /// "These functions return a value greater than or equal to zero if neither
@@ -29,11 +28,3 @@ fn __getf2(a: f128, b: f128) callconv(.C) i32 {
 fn __gttf2(a: f128, b: f128) callconv(.C) i32 {
     return __getf2(a, b);
 }
-
-fn __gekf2(a: f128, b: f128) callconv(.C) i32 {
-    return __getf2(a, b);
-}
-
-fn __gtkf2(a: f128, b: f128) callconv(.C) i32 {
-    return __getf2(a, b);
-}
diff --git a/lib/compiler_rt/log.zig b/lib/compiler_rt/log.zig
index 90a38ba381..5e7085a41b 100644
--- a/lib/compiler_rt/log.zig
+++ b/lib/compiler_rt/log.zig
@@ -18,8 +18,10 @@ comptime {
     @export(logf, .{ .name = "logf", .linkage = common.linkage });
     @export(log, .{ .name = "log", .linkage = common.linkage });
     @export(__logx, .{ .name = "__logx", .linkage = common.linkage });
-    const logq_sym_name = if (common.want_ppc_abi) "logf128" else "logq";
-    @export(logq, .{ .name = logq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(logq, .{ .name = "logf128", .linkage = common.linkage });
+    }
+    @export(logq, .{ .name = "logq", .linkage = common.linkage });
     @export(logl, .{ .name = "logl", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/log10.zig b/lib/compiler_rt/log10.zig
index 406eb8d0c1..54638cc645 100644
--- a/lib/compiler_rt/log10.zig
+++ b/lib/compiler_rt/log10.zig
@@ -19,8 +19,10 @@ comptime {
     @export(log10f, .{ .name = "log10f", .linkage = common.linkage });
     @export(log10, .{ .name = "log10", .linkage = common.linkage });
     @export(__log10x, .{ .name = "__log10x", .linkage = common.linkage });
-    const log10q_sym_name = if (common.want_ppc_abi) "log10f128" else "log10q";
-    @export(log10q, .{ .name = log10q_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(log10q, .{ .name = "log10f128", .linkage = common.linkage });
+    }
+    @export(log10q, .{ .name = "log10q", .linkage = common.linkage });
     @export(log10l, .{ .name = "log10l", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/log2.zig b/lib/compiler_rt/log2.zig
index 6f6c07212a..8298c3dbe3 100644
--- a/lib/compiler_rt/log2.zig
+++ b/lib/compiler_rt/log2.zig
@@ -19,8 +19,10 @@ comptime {
     @export(log2f, .{ .name = "log2f", .linkage = common.linkage });
     @export(log2, .{ .name = "log2", .linkage = common.linkage });
     @export(__log2x, .{ .name = "__log2x", .linkage = common.linkage });
-    const log2q_sym_name = if (common.want_ppc_abi) "log2f128" else "log2q";
-    @export(log2q, .{ .name = log2q_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(log2q, .{ .name = "log2f128", .linkage = common.linkage });
+    }
+    @export(log2q, .{ .name = "log2q", .linkage = common.linkage });
     @export(log2l, .{ .name = "log2l", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/multf3.zig b/lib/compiler_rt/multf3.zig
index d4449ab72e..878cd5c4ac 100644
--- a/lib/compiler_rt/multf3.zig
+++ b/lib/compiler_rt/multf3.zig
@@ -5,22 +5,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__mulkf3, .{ .name = "__mulkf3", .linkage = common.linkage });
+        @export(__multf3, .{ .name = "__mulkf3", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_mul, .{ .name = "_Qp_mul", .linkage = common.linkage });
-    } else {
-        @export(__multf3, .{ .name = "__multf3", .linkage = common.linkage });
     }
+    @export(__multf3, .{ .name = "__multf3", .linkage = common.linkage });
 }
 
 pub fn __multf3(a: f128, b: f128) callconv(.C) f128 {
     return mulf3(f128, a, b);
 }
 
-fn __mulkf3(a: f128, b: f128) callconv(.C) f128 {
-    return mulf3(f128, a, b);
-}
-
 fn _Qp_mul(c: *f128, a: *const f128, b: *const f128) callconv(.C) void {
     c.* = mulf3(f128, a.*, b.*);
 }
diff --git a/lib/compiler_rt/round.zig b/lib/compiler_rt/round.zig
index acd26d8823..8f4b390361 100644
--- a/lib/compiler_rt/round.zig
+++ b/lib/compiler_rt/round.zig
@@ -18,8 +18,10 @@ comptime {
     @export(roundf, .{ .name = "roundf", .linkage = common.linkage });
     @export(round, .{ .name = "round", .linkage = common.linkage });
     @export(__roundx, .{ .name = "__roundx", .linkage = common.linkage });
-    const roundq_sym_name = if (common.want_ppc_abi) "roundf128" else "roundq";
-    @export(roundq, .{ .name = roundq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(roundq, .{ .name = "roundf128", .linkage = common.linkage });
+    }
+    @export(roundq, .{ .name = "roundq", .linkage = common.linkage });
     @export(roundl, .{ .name = "roundl", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/sin.zig b/lib/compiler_rt/sin.zig
index 1b93aab948..b6d388bf0a 100644
--- a/lib/compiler_rt/sin.zig
+++ b/lib/compiler_rt/sin.zig
@@ -22,8 +22,10 @@ comptime {
     @export(sinf, .{ .name = "sinf", .linkage = common.linkage });
     @export(sin, .{ .name = "sin", .linkage = common.linkage });
     @export(__sinx, .{ .name = "__sinx", .linkage = common.linkage });
-    const sinq_sym_name = if (common.want_ppc_abi) "sinf128" else "sinq";
-    @export(sinq, .{ .name = sinq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(sinq, .{ .name = "sinf128", .linkage = common.linkage });
+    }
+    @export(sinq, .{ .name = "sinq", .linkage = common.linkage });
     @export(sinl, .{ .name = "sinl", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/sincos.zig b/lib/compiler_rt/sincos.zig
index c839356a36..30a2b55d95 100644
--- a/lib/compiler_rt/sincos.zig
+++ b/lib/compiler_rt/sincos.zig
@@ -14,8 +14,10 @@ comptime {
     @export(sincosf, .{ .name = "sincosf", .linkage = common.linkage });
     @export(sincos, .{ .name = "sincos", .linkage = common.linkage });
     @export(__sincosx, .{ .name = "__sincosx", .linkage = common.linkage });
-    const sincosq_sym_name = if (common.want_ppc_abi) "sincosf128" else "sincosq";
-    @export(sincosq, .{ .name = sincosq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(sincosq, .{ .name = "sincosf128", .linkage = common.linkage });
+    }
+    @export(sincosq, .{ .name = "sincosq", .linkage = common.linkage });
     @export(sincosl, .{ .name = "sincosl", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/sqrt.zig b/lib/compiler_rt/sqrt.zig
index 01b09213fe..924a8dc9f9 100644
--- a/lib/compiler_rt/sqrt.zig
+++ b/lib/compiler_rt/sqrt.zig
@@ -11,8 +11,10 @@ comptime {
     @export(sqrtf, .{ .name = "sqrtf", .linkage = common.linkage });
     @export(sqrt, .{ .name = "sqrt", .linkage = common.linkage });
     @export(__sqrtx, .{ .name = "__sqrtx", .linkage = common.linkage });
-    const sqrtq_sym_name = if (common.want_ppc_abi) "sqrtf128" else "sqrtq";
-    @export(sqrtq, .{ .name = sqrtq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(sqrtq, .{ .name = "sqrtf128", .linkage = common.linkage });
+    }
+    @export(sqrtq, .{ .name = "sqrtq", .linkage = common.linkage });
     @export(sqrtl, .{ .name = "sqrtl", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/subtf3.zig b/lib/compiler_rt/subtf3.zig
index 9477f96917..4a0d833f57 100644
--- a/lib/compiler_rt/subtf3.zig
+++ b/lib/compiler_rt/subtf3.zig
@@ -4,22 +4,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__subkf3, .{ .name = "__subkf3", .linkage = common.linkage });
+        @export(__subtf3, .{ .name = "__subkf3", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_sub, .{ .name = "_Qp_sub", .linkage = common.linkage });
-    } else {
-        @export(__subtf3, .{ .name = "__subtf3", .linkage = common.linkage });
     }
+    @export(__subtf3, .{ .name = "__subtf3", .linkage = common.linkage });
 }
 
 pub fn __subtf3(a: f128, b: f128) callconv(.C) f128 {
     return sub(a, b);
 }
 
-fn __subkf3(a: f128, b: f128) callconv(.C) f128 {
-    return sub(a, b);
-}
-
 fn _Qp_sub(c: *f128, a: *const f128, b: *const f128) callconv(.C) void {
     c.* = sub(a.*, b.*);
 }
diff --git a/lib/compiler_rt/trunc.zig b/lib/compiler_rt/trunc.zig
index 9ced5bc92c..f600dff61f 100644
--- a/lib/compiler_rt/trunc.zig
+++ b/lib/compiler_rt/trunc.zig
@@ -18,8 +18,10 @@ comptime {
     @export(truncf, .{ .name = "truncf", .linkage = common.linkage });
     @export(trunc, .{ .name = "trunc", .linkage = common.linkage });
     @export(__truncx, .{ .name = "__truncx", .linkage = common.linkage });
-    const truncq_sym_name = if (common.want_ppc_abi) "truncf128" else "truncq";
-    @export(truncq, .{ .name = truncq_sym_name, .linkage = common.linkage });
+    if (common.want_ppc_abi) {
+        @export(truncq, .{ .name = "truncf128", .linkage = common.linkage });
+    }
+    @export(truncq, .{ .name = "truncq", .linkage = common.linkage });
     @export(truncl, .{ .name = "truncl", .linkage = common.linkage });
 }
 
diff --git a/lib/compiler_rt/trunctfdf2.zig b/lib/compiler_rt/trunctfdf2.zig
index e084d63d88..02be252856 100644
--- a/lib/compiler_rt/trunctfdf2.zig
+++ b/lib/compiler_rt/trunctfdf2.zig
@@ -5,22 +5,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__trunckfdf2, .{ .name = "__trunckfdf2", .linkage = common.linkage });
+        @export(__trunctfdf2, .{ .name = "__trunckfdf2", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_qtod, .{ .name = "_Qp_qtod", .linkage = common.linkage });
-    } else {
-        @export(__trunctfdf2, .{ .name = "__trunctfdf2", .linkage = common.linkage });
     }
+    @export(__trunctfdf2, .{ .name = "__trunctfdf2", .linkage = common.linkage });
 }
 
 pub fn __trunctfdf2(a: f128) callconv(.C) f64 {
     return truncf(f64, f128, a);
 }
 
-fn __trunckfdf2(a: f128) callconv(.C) f64 {
-    return truncf(f64, f128, a);
-}
-
 fn _Qp_qtod(a: *const f128) callconv(.C) f64 {
     return truncf(f64, f128, a.*);
 }
diff --git a/lib/compiler_rt/trunctfsf2.zig b/lib/compiler_rt/trunctfsf2.zig
index 0fcd5e1e08..88a3668a93 100644
--- a/lib/compiler_rt/trunctfsf2.zig
+++ b/lib/compiler_rt/trunctfsf2.zig
@@ -5,22 +5,17 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__trunckfsf2, .{ .name = "__trunckfsf2", .linkage = common.linkage });
+        @export(__trunctfsf2, .{ .name = "__trunckfsf2", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         @export(_Qp_qtos, .{ .name = "_Qp_qtos", .linkage = common.linkage });
-    } else {
-        @export(__trunctfsf2, .{ .name = "__trunctfsf2", .linkage = common.linkage });
     }
+    @export(__trunctfsf2, .{ .name = "__trunctfsf2", .linkage = common.linkage });
 }
 
 pub fn __trunctfsf2(a: f128) callconv(.C) f32 {
     return truncf(f32, f128, a);
 }
 
-fn __trunckfsf2(a: f128) callconv(.C) f32 {
-    return truncf(f32, f128, a);
-}
-
 fn _Qp_qtos(a: *const f128) callconv(.C) f32 {
     return truncf(f32, f128, a.*);
 }
diff --git a/lib/compiler_rt/unordtf2.zig b/lib/compiler_rt/unordtf2.zig
index 41d1d7008e..e00d9cc6d1 100644
--- a/lib/compiler_rt/unordtf2.zig
+++ b/lib/compiler_rt/unordtf2.zig
@@ -5,19 +5,14 @@ pub const panic = common.panic;
 
 comptime {
     if (common.want_ppc_abi) {
-        @export(__unordkf2, .{ .name = "__unordkf2", .linkage = common.linkage });
+        @export(__unordtf2, .{ .name = "__unordkf2", .linkage = common.linkage });
     } else if (common.want_sparc_abi) {
         // These exports are handled in cmptf2.zig because unordered comparisons
         // are based on calling _Qp_cmp.
-    } else {
-        @export(__unordtf2, .{ .name = "__unordtf2", .linkage = common.linkage });
     }
+    @export(__unordtf2, .{ .name = "__unordtf2", .linkage = common.linkage });
 }
 
 fn __unordtf2(a: f128, b: f128) callconv(.C) i32 {
     return comparef.unordcmp(f128, a, b);
 }
-
-fn __unordkf2(a: f128, b: f128) callconv(.C) i32 {
-    return comparef.unordcmp(f128, a, b);
-}

From c96f85852ed2e1d5b2ecb43770a3c41d7f38f284 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Sat, 22 Oct 2022 17:25:02 -0700
Subject: [PATCH 05/70] CType: Add `preferredAlignment`

This value corresponds to clang/gcc's `__alignof` (rather than
`_Alignof` which reports the minimum alignment). We don't use this
information yet, but it might be useful for implementing ABIs so it
is included here.
---
 src/type.zig | 128 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 127 insertions(+), 1 deletion(-)

diff --git a/src/type.zig b/src/type.zig
index 51b326e18e..d78e2909b5 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -6926,7 +6926,7 @@ pub const CType = enum {
             else => {},
         }
 
-        // Self-aligned, up to a maximum.
+        // Next-power-of-two-aligned, up to a maximum.
         return @min(
             std.math.ceilPowerOfTwoAssert(u16, (self.sizeInBits(target) + 7) / 8),
             switch (target.cpu.arch) {
@@ -7013,4 +7013,130 @@ pub const CType = enum {
             },
         );
     }
+
+    pub fn preferredAlignment(self: CType, target: Target) u16 {
+
+        // Overrides for unusual alignments
+        switch (target.cpu.arch) {
+            .arm, .armeb, .thumb, .thumbeb => switch (target.os.tag) {
+                .netbsd => switch (target.abi) {
+                    .gnueabi,
+                    .gnueabihf,
+                    .eabi,
+                    .eabihf,
+                    .android,
+                    .musleabi,
+                    .musleabihf,
+                    => {},
+
+                    else => switch (self) {
+                        .longdouble => return 4,
+                        else => {},
+                    },
+                },
+                .ios, .tvos, .watchos => switch (self) {
+                    .longdouble => return 4,
+                    else => {},
+                },
+                else => {},
+            },
+            .arc => switch (self) {
+                .longdouble => return 4,
+                else => {},
+            },
+            .avr => switch (self) {
+                .int, .uint, .long, .ulong, .float, .longdouble => return 1,
+                .short, .ushort => return 2,
+                .double => return 4,
+                .longlong, .ulonglong => return 8,
+            },
+            .i386 => switch (target.os.tag) {
+                .windows, .uefi => switch (self) {
+                    .longdouble => switch (target.abi) {
+                        .gnu, .gnuilp32, .cygnus => return 4,
+                        else => return 8,
+                    },
+                    else => {},
+                },
+                else => switch (self) {
+                    .longdouble => return 4,
+                    else => {},
+                },
+            },
+            else => {},
+        }
+
+        // Next-power-of-two-aligned, up to a maximum.
+        return @min(
+            std.math.ceilPowerOfTwoAssert(u16, (self.sizeInBits(target) + 7) / 8),
+            switch (target.cpu.arch) {
+                .msp430 => @as(u16, 2),
+
+                .csky,
+                .xcore,
+                .dxil,
+                .loongarch32,
+                .tce,
+                .tcele,
+                .le32,
+                .amdil,
+                .hsail,
+                .spir,
+                .spirv32,
+                .kalimba,
+                .shave,
+                .renderscript32,
+                .ve,
+                .spu_2,
+                => 4,
+
+                .arc,
+                .arm,
+                .armeb,
+                .avr,
+                .thumb,
+                .thumbeb,
+                .aarch64_32,
+                .amdgcn,
+                .amdil64,
+                .bpfel,
+                .bpfeb,
+                .hexagon,
+                .hsail64,
+                .i386,
+                .loongarch64,
+                .m68k,
+                .mips,
+                .mipsel,
+                .sparc,
+                .sparcel,
+                .sparc64,
+                .lanai,
+                .le64,
+                .nvptx,
+                .nvptx64,
+                .r600,
+                .s390x,
+                .spir64,
+                .spirv64,
+                .renderscript64,
+                => 8,
+
+                .aarch64,
+                .aarch64_be,
+                .mips64,
+                .mips64el,
+                .powerpc,
+                .powerpcle,
+                .powerpc64,
+                .powerpc64le,
+                .riscv32,
+                .riscv64,
+                .x86_64,
+                .wasm32,
+                .wasm64,
+                => 16,
+            },
+        );
+    }
 };

From 4ecc384f99e5f4c5a320714484866fb48699245f Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Sun, 23 Oct 2022 23:17:23 -0700
Subject: [PATCH 06/70] Fix long double on x86_64-windows

The larger alignment on this platform means that long double reports
a sizeof 16 bytes, but it's underlying size is really just the 10
bytes of `f80`

C doesn't give us a way to see the "underlying" size of a type, so
this has to be caught by hand or by monitoring runtime memory. Luckily,
x86 and x86-64 are the only platforms that seem to use a non-power-of-two
type like this.
---
 src/type.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/type.zig b/src/type.zig
index d78e2909b5..8f2cd7c54d 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -6827,7 +6827,7 @@ pub const CType = enum {
                     },
                     .longlong, .ulonglong, .double => return 64,
                     .longdouble => switch (target.abi) {
-                        .gnu, .gnuilp32, .cygnus => return 128,
+                        .gnu, .gnuilp32, .cygnus => return 80,
                         else => return 64,
                     },
                 },

From 55c5da1b205dc5eddd2749381caacf28bea6f90e Mon Sep 17 00:00:00 2001
From: Jacob Young <jacobly0@users.noreply.github.com>
Date: Tue, 25 Oct 2022 05:06:54 -0400
Subject: [PATCH 07/70] fmt: fix f80 hex formatting

These ifs were missing a case for f80 which should have shifted by one,
but we can just compute the correct value instead.  Also, we want the
fractional bits to be a multiple of four, not the mantissa bits, since
the mantissa could have a leading one which we want to be separated.
---
 lib/std/fmt.zig | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/lib/std/fmt.zig b/lib/std/fmt.zig
index 0c9ecbc08c..0fcb2ae5b1 100644
--- a/lib/std/fmt.zig
+++ b/lib/std/fmt.zig
@@ -1207,10 +1207,9 @@ pub fn formatFloatHexadecimal(
             mantissa |= 1 << fractional_bits; // Add the implicit integer bit.
     }
 
-    // Fill in zeroes to round the mantissa width to a multiple of 4.
-    if (T == f16) mantissa <<= 2 else if (T == f32) mantissa <<= 1;
-
     const mantissa_digits = (fractional_bits + 3) / 4;
+    // Fill in zeroes to round the fraction width to a multiple of 4.
+    mantissa <<= mantissa_digits * 4 - fractional_bits;
 
     if (options.precision) |precision| {
         // Round if needed.
@@ -2317,21 +2316,25 @@ test "float.hexadecimal" {
     try expectFmt("f16: 0x1.554p-2", "f16: {x}", .{@as(f16, 1.0 / 3.0)});
     try expectFmt("f32: 0x1.555556p-2", "f32: {x}", .{@as(f32, 1.0 / 3.0)});
     try expectFmt("f64: 0x1.5555555555555p-2", "f64: {x}", .{@as(f64, 1.0 / 3.0)});
+    try expectFmt("f80: 0x1.5555555555555556p-2", "f80: {x}", .{@as(f80, 1.0 / 3.0)});
     try expectFmt("f128: 0x1.5555555555555555555555555555p-2", "f128: {x}", .{@as(f128, 1.0 / 3.0)});
 
     try expectFmt("f16: 0x1p-14", "f16: {x}", .{math.floatMin(f16)});
     try expectFmt("f32: 0x1p-126", "f32: {x}", .{math.floatMin(f32)});
     try expectFmt("f64: 0x1p-1022", "f64: {x}", .{math.floatMin(f64)});
+    try expectFmt("f80: 0x1p-16382", "f80: {x}", .{math.floatMin(f80)});
     try expectFmt("f128: 0x1p-16382", "f128: {x}", .{math.floatMin(f128)});
 
     try expectFmt("f16: 0x0.004p-14", "f16: {x}", .{math.floatTrueMin(f16)});
     try expectFmt("f32: 0x0.000002p-126", "f32: {x}", .{math.floatTrueMin(f32)});
     try expectFmt("f64: 0x0.0000000000001p-1022", "f64: {x}", .{math.floatTrueMin(f64)});
+    try expectFmt("f80: 0x0.0000000000000002p-16382", "f80: {x}", .{math.floatTrueMin(f80)});
     try expectFmt("f128: 0x0.0000000000000000000000000001p-16382", "f128: {x}", .{math.floatTrueMin(f128)});
 
     try expectFmt("f16: 0x1.ffcp15", "f16: {x}", .{math.floatMax(f16)});
     try expectFmt("f32: 0x1.fffffep127", "f32: {x}", .{math.floatMax(f32)});
     try expectFmt("f64: 0x1.fffffffffffffp1023", "f64: {x}", .{math.floatMax(f64)});
+    try expectFmt("f80: 0x1.fffffffffffffffep16383", "f80: {x}", .{math.floatMax(f80)});
     try expectFmt("f128: 0x1.ffffffffffffffffffffffffffffp16383", "f128: {x}", .{math.floatMax(f128)});
 }
 
@@ -2339,11 +2342,13 @@ test "float.hexadecimal.precision" {
     try expectFmt("f16: 0x1.5p-2", "f16: {x:.1}", .{@as(f16, 1.0 / 3.0)});
     try expectFmt("f32: 0x1.555p-2", "f32: {x:.3}", .{@as(f32, 1.0 / 3.0)});
     try expectFmt("f64: 0x1.55555p-2", "f64: {x:.5}", .{@as(f64, 1.0 / 3.0)});
-    try expectFmt("f128: 0x1.5555555p-2", "f128: {x:.7}", .{@as(f128, 1.0 / 3.0)});
+    try expectFmt("f80: 0x1.5555555p-2", "f80: {x:.7}", .{@as(f80, 1.0 / 3.0)});
+    try expectFmt("f128: 0x1.555555555p-2", "f128: {x:.9}", .{@as(f128, 1.0 / 3.0)});
 
     try expectFmt("f16: 0x1.00000p0", "f16: {x:.5}", .{@as(f16, 1.0)});
     try expectFmt("f32: 0x1.00000p0", "f32: {x:.5}", .{@as(f32, 1.0)});
     try expectFmt("f64: 0x1.00000p0", "f64: {x:.5}", .{@as(f64, 1.0)});
+    try expectFmt("f80: 0x1.00000p0", "f80: {x:.5}", .{@as(f80, 1.0)});
     try expectFmt("f128: 0x1.00000p0", "f128: {x:.5}", .{@as(f128, 1.0)});
 }
 

From 98285b17b3887de37b630da66f09a44f42ddbe01 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Tue, 25 Oct 2022 11:46:42 +0200
Subject: [PATCH 08/70] darwin: bump max macOS version to 13.0

---
 lib/std/target.zig | 4 ++--
 src/target.zig     | 2 ++
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/lib/std/target.zig b/lib/std/target.zig
index d791e3b035..7fbad5baa3 100644
--- a/lib/std/target.zig
+++ b/lib/std/target.zig
@@ -277,13 +277,13 @@ pub const Target = struct {
                         .aarch64 => VersionRange{
                             .semver = .{
                                 .min = .{ .major = 11, .minor = 6, .patch = 6 },
-                                .max = .{ .major = 12, .minor = 4 },
+                                .max = .{ .major = 13, .minor = 0 },
                             },
                         },
                         .x86_64 => VersionRange{
                             .semver = .{
                                 .min = .{ .major = 10, .minor = 15, .patch = 7 },
-                                .max = .{ .major = 12, .minor = 4 },
+                                .max = .{ .major = 13, .minor = 0 },
                             },
                         },
                         else => unreachable,
diff --git a/src/target.zig b/src/target.zig
index 9e2d26dac6..fc585912c4 100644
--- a/src/target.zig
+++ b/src/target.zig
@@ -18,6 +18,7 @@ pub const available_libcs = [_]ArchOsAbi{
     .{ .arch = .aarch64, .os = .windows, .abi = .gnu },
     .{ .arch = .aarch64, .os = .macos, .abi = .none, .os_ver = .{ .major = 11, .minor = 0 } },
     .{ .arch = .aarch64, .os = .macos, .abi = .none, .os_ver = .{ .major = 12, .minor = 0 } },
+    .{ .arch = .aarch64, .os = .macos, .abi = .none, .os_ver = .{ .major = 13, .minor = 0 } },
     .{ .arch = .armeb, .os = .linux, .abi = .gnueabi },
     .{ .arch = .armeb, .os = .linux, .abi = .gnueabihf },
     .{ .arch = .armeb, .os = .linux, .abi = .musleabi },
@@ -73,6 +74,7 @@ pub const available_libcs = [_]ArchOsAbi{
     .{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 10, .minor = 0 } },
     .{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 11, .minor = 0 } },
     .{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 12, .minor = 0 } },
+    .{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 13, .minor = 0 } },
 };
 
 pub fn libCGenericName(target: std.Target) [:0]const u8 {

From 2d03f389881fbbbd2aa197de523c96d2f7593b7d Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Tue, 25 Oct 2022 20:30:15 +0200
Subject: [PATCH 09/70] darwin: bump minimum supported version to 11.7.1

Drop Catalina support.
---
 lib/std/target.zig | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/std/target.zig b/lib/std/target.zig
index 7fbad5baa3..c973ec5c1b 100644
--- a/lib/std/target.zig
+++ b/lib/std/target.zig
@@ -276,13 +276,13 @@ pub const Target = struct {
                     .macos => return switch (arch) {
                         .aarch64 => VersionRange{
                             .semver = .{
-                                .min = .{ .major = 11, .minor = 6, .patch = 6 },
+                                .min = .{ .major = 11, .minor = 7, .patch = 1 },
                                 .max = .{ .major = 13, .minor = 0 },
                             },
                         },
                         .x86_64 => VersionRange{
                             .semver = .{
-                                .min = .{ .major = 10, .minor = 15, .patch = 7 },
+                                .min = .{ .major = 11, .minor = 7, .patch = 1 },
                                 .max = .{ .major = 13, .minor = 0 },
                             },
                         },

From 43dbebdd8dbccd00bd50c2df3d9d7ef8bfcddb36 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Tue, 25 Oct 2022 13:14:04 +0200
Subject: [PATCH 10/70] darwin: add libSystem.13.tbd

---
 lib/libc/darwin/libSystem.13.tbd | 3931 ++++++++++++++++++++++++++++++
 1 file changed, 3931 insertions(+)
 create mode 100644 lib/libc/darwin/libSystem.13.tbd

diff --git a/lib/libc/darwin/libSystem.13.tbd b/lib/libc/darwin/libSystem.13.tbd
new file mode 100644
index 0000000000..b912905aaa
--- /dev/null
+++ b/lib/libc/darwin/libSystem.13.tbd
@@ -0,0 +1,3931 @@
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           1C88C6B7-F992-3275-9EF4-4D2CB1CEFAC3
+  - target:          x86_64-maccatalyst
+    value:           1C88C6B7-F992-3275-9EF4-4D2CB1CEFAC3
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           4396C12B-BA04-34F0-B859-7FC1914064A3
+  - target:          arm64e-maccatalyst
+    value:           4396C12B-BA04-34F0-B859-7FC1914064A3
+install-name:    '/usr/lib/libSystem.B.dylib'
+current-version: 1319
+reexported-libraries:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    libraries:       [ '/usr/lib/system/libcache.dylib', '/usr/lib/system/libcommonCrypto.dylib', 
+                       '/usr/lib/system/libcompiler_rt.dylib', '/usr/lib/system/libcopyfile.dylib', 
+                       '/usr/lib/system/libcorecrypto.dylib', '/usr/lib/system/libdispatch.dylib', 
+                       '/usr/lib/system/libdyld.dylib', '/usr/lib/system/libkeymgr.dylib', 
+                       '/usr/lib/system/libmacho.dylib', '/usr/lib/system/libquarantine.dylib', 
+                       '/usr/lib/system/libremovefile.dylib', '/usr/lib/system/libsystem_asl.dylib', 
+                       '/usr/lib/system/libsystem_blocks.dylib', '/usr/lib/system/libsystem_c.dylib', 
+                       '/usr/lib/system/libsystem_collections.dylib', '/usr/lib/system/libsystem_configuration.dylib', 
+                       '/usr/lib/system/libsystem_containermanager.dylib', '/usr/lib/system/libsystem_coreservices.dylib', 
+                       '/usr/lib/system/libsystem_darwin.dylib', '/usr/lib/system/libsystem_dnssd.dylib', 
+                       '/usr/lib/system/libsystem_featureflags.dylib', '/usr/lib/system/libsystem_info.dylib', 
+                       '/usr/lib/system/libsystem_kernel.dylib', '/usr/lib/system/libsystem_m.dylib', 
+                       '/usr/lib/system/libsystem_malloc.dylib', '/usr/lib/system/libsystem_networkextension.dylib', 
+                       '/usr/lib/system/libsystem_notify.dylib', '/usr/lib/system/libsystem_platform.dylib', 
+                       '/usr/lib/system/libsystem_pthread.dylib', '/usr/lib/system/libsystem_sandbox.dylib', 
+                       '/usr/lib/system/libsystem_secinit.dylib', '/usr/lib/system/libsystem_symptoms.dylib', 
+                       '/usr/lib/system/libsystem_trace.dylib', '/usr/lib/system/libunwind.dylib', 
+                       '/usr/lib/system/libxpc.dylib' ]
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
+    symbols:         [ 'R8289209$_close', 'R8289209$_fork', 'R8289209$_fsync', 'R8289209$_getattrlist', 
+                       'R8289209$_getrlimit', 'R8289209$_getxattr', 'R8289209$_open', 
+                       'R8289209$_pthread_attr_destroy', 'R8289209$_pthread_attr_init', 
+                       'R8289209$_pthread_attr_setdetachstate', 'R8289209$_pthread_create', 
+                       'R8289209$_pthread_mutex_lock', 'R8289209$_pthread_mutex_unlock', 
+                       'R8289209$_pthread_self', 'R8289209$_ptrace', 'R8289209$_read', 
+                       'R8289209$_setattrlist', 'R8289209$_setrlimit', 'R8289209$_sigaction', 
+                       'R8289209$_stat', 'R8289209$_sysctl', 'R8289209$_time', 'R8289209$_unlink', 
+                       'R8289209$_write' ]
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ ___crashreporter_info__, _libSystem_init_after_boot_tasks_4launchd, 
+                       _mach_init_routine ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           0D42BFC6-F62E-342B-BDB1-E75B48AF5081
+  - target:          x86_64-maccatalyst
+    value:           0D42BFC6-F62E-342B-BDB1-E75B48AF5081
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           9953AE27-E8CB-32B2-98AF-9E871BCDD5D3
+  - target:          arm64e-maccatalyst
+    value:           9953AE27-E8CB-32B2-98AF-9E871BCDD5D3
+install-name:    '/usr/lib/system/libcache.dylib'
+current-version: 90
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _cache_create, _cache_destroy, _cache_get, _cache_get_and_retain, 
+                       _cache_get_cost_hint, _cache_get_count_hint, _cache_get_info, 
+                       _cache_get_info_for_key, _cache_get_info_for_keys, _cache_get_minimum_values_hint, 
+                       _cache_get_name, _cache_hash_byte_string, _cache_invoke, _cache_key_hash_cb_cstring, 
+                       _cache_key_hash_cb_integer, _cache_key_is_equal_cb_cstring, 
+                       _cache_key_is_equal_cb_integer, _cache_print, _cache_print_stats, 
+                       _cache_release, _cache_release_cb_free, _cache_release_value, 
+                       _cache_remove, _cache_remove_all, _cache_remove_with_block, 
+                       _cache_retain, _cache_set_and_retain, _cache_set_cost_hint, 
+                       _cache_set_count_hint, _cache_set_minimum_values_hint, _cache_set_name, 
+                       _cache_simulate_memory_warning_event, _cache_value_make_nonpurgeable_cb, 
+                       _cache_value_make_purgeable_cb ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           DD06A475-50C9-3264-BAD5-479DA5E8B327
+  - target:          x86_64-maccatalyst
+    value:           DD06A475-50C9-3264-BAD5-479DA5E8B327
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           7510671C-686A-339D-8F50-B95BFA5D8F10
+  - target:          arm64e-maccatalyst
+    value:           7510671C-686A-339D-8F50-B95BFA5D8F10
+install-name:    '/usr/lib/system/libcommonCrypto.dylib'
+current-version: 60198.40.3
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _CCAESCmac, _CCAESCmacCreate, _CCAESCmacDestroy, _CCAESCmacFinal, 
+                       _CCAESCmacOutputSizeFromContext, _CCAESCmacUpdate, _CCBigNumAdd, 
+                       _CCBigNumAddI, _CCBigNumBitCount, _CCBigNumByteCount, _CCBigNumClear, 
+                       _CCBigNumCompare, _CCBigNumCompareI, _CCBigNumCopy, _CCBigNumCreateRandom, 
+                       _CCBigNumDiv, _CCBigNumFree, _CCBigNumFromData, _CCBigNumFromDecimalString, 
+                       _CCBigNumFromHexString, _CCBigNumGetI, _CCBigNumIsNegative, 
+                       _CCBigNumIsPrime, _CCBigNumIsZero, _CCBigNumLeftShift, _CCBigNumMod, 
+                       _CCBigNumModExp, _CCBigNumModI, _CCBigNumMul, _CCBigNumMulI, 
+                       _CCBigNumMulMod, _CCBigNumRightShift, _CCBigNumSetI, _CCBigNumSetNegative, 
+                       _CCBigNumSub, _CCBigNumSubI, _CCBigNumToData, _CCBigNumToDecimalString, 
+                       _CCBigNumToHexString, _CCBigNumZeroLSBCount, _CCCKGContributorCommit, 
+                       _CCCKGContributorCreate, _CCCKGContributorDestroy, _CCCKGContributorFinish, 
+                       _CCCKGGetCommitmentSize, _CCCKGGetOpeningSize, _CCCKGGetShareSize, 
+                       _CCCKGOwnerCreate, _CCCKGOwnerDestroy, _CCCKGOwnerFinish, 
+                       _CCCKGOwnerGenerateShare, _CCCalibratePBKDF, _CCCreateBigNum, 
+                       _CCCrypt, _CCCryptorAddParameter, _CCCryptorChaCha20, _CCCryptorChaCha20Poly1305OneshotDecrypt, 
+                       _CCCryptorChaCha20Poly1305OneshotEncrypt, _CCCryptorCreate, 
+                       _CCCryptorCreateFromData, _CCCryptorCreateFromDataWithMode, 
+                       _CCCryptorCreateWithMode, _CCCryptorDecryptDataBlock, _CCCryptorEncryptDataBlock, 
+                       _CCCryptorFinal, _CCCryptorGCM, _CCCryptorGCMAddAAD, _CCCryptorGCMAddADD, 
+                       _CCCryptorGCMAddIV, _CCCryptorGCMDecrypt, _CCCryptorGCMEncrypt, 
+                       _CCCryptorGCMFinal, _CCCryptorGCMFinalize, _CCCryptorGCMOneshotDecrypt, 
+                       _CCCryptorGCMOneshotEncrypt, _CCCryptorGCMReset, _CCCryptorGCMSetIV, 
+                       _CCCryptorGCMaddAAD, _CCCryptorGetIV, _CCCryptorGetOutputLength, 
+                       _CCCryptorGetParameter, _CCCryptorRelease, _CCCryptorReset, 
+                       _CCCryptorReset_binary_compatibility, _CCCryptorUpdate, _CCDHComputeKey, 
+                       _CCDHCreate, _CCDHGenerateKey, _CCDHRelease, _CCDeriveKey, 
+                       _CCDesCBCCksum, _CCDesIsWeakKey, _CCDesSetOddParity, _CCDigest, 
+                       _CCDigestBlockSize, _CCDigestCreate, _CCDigestCreateByOID, 
+                       _CCDigestDestroy, _CCDigestFinal, _CCDigestGetBlockSize, _CCDigestGetBlockSizeFromRef, 
+                       _CCDigestGetOutputSize, _CCDigestGetOutputSizeFromRef, _CCDigestInit, 
+                       _CCDigestOID, _CCDigestOIDLen, _CCDigestOutputSize, _CCDigestReset, 
+                       _CCDigestUpdate, _CCECCryptorBlind, _CCECCryptorBlindingKeysRelease, 
+                       _CCECCryptorComputeSharedSecret, _CCECCryptorCreateFromData, 
+                       _CCECCryptorExportKey, _CCECCryptorExportPublicKey, _CCECCryptorGenerateBlindingKeys, 
+                       _CCECCryptorGeneratePair, _CCECCryptorGetKeyComponents, _CCECCryptorGetPublicKeyFromPrivateKey, 
+                       _CCECCryptorH2C, _CCECCryptorImportKey, _CCECCryptorImportPublicKey, 
+                       _CCECCryptorRelease, _CCECCryptorSignHash, _CCECCryptorTwinDiversifyEntropySize, 
+                       _CCECCryptorTwinDiversifyKey, _CCECCryptorUnblind, _CCECCryptorUnwrapKey, 
+                       _CCECCryptorVerifyHash, _CCECCryptorWrapKey, _CCECGetKeySize, 
+                       _CCECGetKeyType, _CCHKDFExpand, _CCHKDFExtract, _CCHmac, _CCHmacClone, 
+                       _CCHmacCreate, _CCHmacDestroy, _CCHmacFinal, _CCHmacInit, 
+                       _CCHmacOneShot, _CCHmacOutputSize, _CCHmacOutputSizeFromRef, 
+                       _CCHmacUpdate, _CCKDFParametersCreateAnsiX963, _CCKDFParametersCreateCtrHmac, 
+                       _CCKDFParametersCreateCtrHmacFixed, _CCKDFParametersCreateHkdf, 
+                       _CCKDFParametersCreatePbkdf2, _CCKDFParametersDestroy, _CCKeyDerivationHMac, 
+                       _CCKeyDerivationPBKDF, _CCRSACryptorCreateFromData, _CCRSACryptorCreatePublicKeyFromPrivateKey, 
+                       _CCRSACryptorCrypt, _CCRSACryptorDecrypt, _CCRSACryptorEncrypt, 
+                       _CCRSACryptorExport, _CCRSACryptorGeneratePair, _CCRSACryptorGetPublicKeyFromPrivateKey, 
+                       _CCRSACryptorImport, _CCRSACryptorRecoverPrivateKey, _CCRSACryptorRelease, 
+                       _CCRSACryptorSign, _CCRSACryptorVerify, _CCRSAGetCRTComponents, 
+                       _CCRSAGetCRTComponentsSizes, _CCRSAGetKeyComponents, _CCRSAGetKeySize, 
+                       _CCRSAGetKeyType, _CCRandomCopyBytes, _CCRandomGenerateBytes, 
+                       _CCRandomUniform, _CCSymmetricKeyUnwrap, _CCSymmetricKeyWrap, 
+                       _CCSymmetricUnwrappedSize, _CCSymmetricWrappedSize, _CC_MD2, 
+                       _CC_MD2_Final, _CC_MD2_Init, _CC_MD2_Update, _CC_MD4, _CC_MD4_Final, 
+                       _CC_MD4_Init, _CC_MD4_Update, _CC_MD5, _CC_MD5_Final, _CC_MD5_Init, 
+                       _CC_MD5_Update, _CC_SHA1, _CC_SHA1_Final, _CC_SHA1_Init, _CC_SHA1_Update, 
+                       _CC_SHA224, _CC_SHA224_Final, _CC_SHA224_Init, _CC_SHA224_Update, 
+                       _CC_SHA256, _CC_SHA256_Final, _CC_SHA256_Init, _CC_SHA256_Update, 
+                       _CC_SHA384, _CC_SHA384_Final, _CC_SHA384_Init, _CC_SHA384_Update, 
+                       _CC_SHA512, _CC_SHA512_Final, _CC_SHA512_Init, _CC_SHA512_Update, 
+                       _CCrfc3394_iv, _CCrfc3394_ivLen, _CNCRC, _CNCRCDumpTable, 
+                       _CNCRCFinal, _CNCRCInit, _CNCRCRelease, _CNCRCUpdate, _CNCRCWeakTest, 
+                       _CNEncode, _CNEncoderBlocksize, _CNEncoderBlocksizeFromRef, 
+                       _CNEncoderCreate, _CNEncoderCreateCustom, _CNEncoderFinal, 
+                       _CNEncoderGetOutputLength, _CNEncoderGetOutputLengthFromEncoding, 
+                       _CNEncoderRelease, _CNEncoderUpdate, _MD5Final, _ccDRBGGetRngState, 
+                       _ccDevRandomGetRngState, _kCCRandomDefault, _kCCRandomDevRandom ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, arm64-macos, arm64e-macos ]
+uuids:
+  - target:          x86_64-macos
+    value:           9053D30C-239D-30B4-B36D-4E3490F72FE4
+  - target:          arm64-macos
+    value:           A7F13C10-9CEA-3A4E-86AB-F65E292E7804
+  - target:          arm64e-macos
+    value:           824DFF0F-A337-32EB-B5DF-3FDD0BBFF9ED
+install-name:    '/usr/lib/system/libcompiler_rt.dylib'
+current-version: 103.1
+parent-umbrella:
+  - targets:         [ x86_64-macos, arm64-macos, arm64e-macos ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos ]
+    symbols:         [ '$ld$hide$os10.4$___absvti2', '$ld$hide$os10.4$___addvti3', 
+                       '$ld$hide$os10.4$___ashlti3', '$ld$hide$os10.4$___ashrti3', 
+                       '$ld$hide$os10.4$___cmpti2', '$ld$hide$os10.4$___ctzti2', 
+                       '$ld$hide$os10.4$___ffsti2', '$ld$hide$os10.4$___fixunsxfti', 
+                       '$ld$hide$os10.4$___fixxfti', '$ld$hide$os10.4$___floattixf', 
+                       '$ld$hide$os10.4$___floatuntixf', '$ld$hide$os10.4$___lshrti3', 
+                       '$ld$hide$os10.4$___multi3', '$ld$hide$os10.4$___mulvti3', 
+                       '$ld$hide$os10.4$___negti2', '$ld$hide$os10.4$___negvti2', 
+                       '$ld$hide$os10.4$___parityti2', '$ld$hide$os10.4$___popcountti2', 
+                       '$ld$hide$os10.4$___subvti3', '$ld$hide$os10.4$___ucmpti2', 
+                       '$ld$hide$os10.5$___absvti2', '$ld$hide$os10.5$___addvti3', 
+                       '$ld$hide$os10.5$___ashlti3', '$ld$hide$os10.5$___ashrti3', 
+                       '$ld$hide$os10.5$___cmpti2', '$ld$hide$os10.5$___ctzti2', 
+                       '$ld$hide$os10.5$___ffsti2', '$ld$hide$os10.5$___fixunsxfti', 
+                       '$ld$hide$os10.5$___fixxfti', '$ld$hide$os10.5$___floattixf', 
+                       '$ld$hide$os10.5$___floatuntixf', '$ld$hide$os10.5$___lshrti3', 
+                       '$ld$hide$os10.5$___multi3', '$ld$hide$os10.5$___mulvti3', 
+                       '$ld$hide$os10.5$___negti2', '$ld$hide$os10.5$___negvti2', 
+                       '$ld$hide$os10.5$___parityti2', '$ld$hide$os10.5$___popcountti2', 
+                       '$ld$hide$os10.5$___subvti3', '$ld$hide$os10.5$___ucmpti2', 
+                       ___absvdi2, ___absvsi2, ___absvti2, ___addvdi3, ___addvsi3, 
+                       ___addvti3, ___ashldi3, ___ashlti3, ___ashrdi3, ___ashrti3, 
+                       ___clzdi2, ___clzsi2, ___cmpdi2, ___cmpti2, ___ctzdi2, ___ctzsi2, 
+                       ___ctzti2, ___divdc3, ___divdi3, ___divsc3, ___divxc3, ___ffsdi2, 
+                       ___ffsti2, ___fixdfdi, ___fixsfdi, ___fixunsdfdi, ___fixunsdfsi, 
+                       ___fixunssfdi, ___fixunssfsi, ___fixunsxfdi, ___fixunsxfsi, 
+                       ___fixunsxfti, ___fixxfdi, ___fixxfti, ___floatdidf, ___floatdisf, 
+                       ___floatdixf, ___floattixf, ___floatundidf, ___floatundisf, 
+                       ___floatundixf, ___floatuntixf, ___lshrdi3, ___lshrti3, ___moddi3, 
+                       ___muldi3, ___mulodi4, ___mulosi4, ___muloti4, ___multi3, 
+                       ___mulvdi3, ___mulvsi3, ___mulvti3, ___mulxc3, ___negdi2, 
+                       ___negti2, ___negvdi2, ___negvsi2, ___negvti2, ___paritydi2, 
+                       ___paritysi2, ___parityti2, ___popcountdi2, ___popcountsi2, 
+                       ___popcountti2, ___powixf2, ___subvdi3, ___subvsi3, ___subvti3, 
+                       ___ucmpdi2, ___ucmpti2, ___udivdi3, ___udivmoddi4, ___umoddi3 ]
+  - targets:         [ x86_64-macos, arm64-macos, arm64e-macos ]
+    symbols:         [ '$ld$hide$os10.10$___chkstk_darwin', '$ld$hide$os10.10$___extendhfsf2', 
+                       '$ld$hide$os10.10$___truncdfhf2', '$ld$hide$os10.10$___truncsfhf2', 
+                       '$ld$hide$os10.10$_atomic_flag_clear', '$ld$hide$os10.10$_atomic_flag_clear_explicit', 
+                       '$ld$hide$os10.10$_atomic_flag_test_and_set', '$ld$hide$os10.10$_atomic_flag_test_and_set_explicit', 
+                       '$ld$hide$os10.10$_atomic_signal_fence', '$ld$hide$os10.10$_atomic_thread_fence', 
+                       '$ld$hide$os10.11$___chkstk_darwin', '$ld$hide$os10.12$___chkstk_darwin', 
+                       '$ld$hide$os10.13$___chkstk_darwin', '$ld$hide$os10.14$___chkstk_darwin', 
+                       '$ld$hide$os10.4$___absvdi2', '$ld$hide$os10.4$___absvsi2', 
+                       '$ld$hide$os10.4$___addvdi3', '$ld$hide$os10.4$___addvsi3', 
+                       '$ld$hide$os10.4$___ashldi3', '$ld$hide$os10.4$___ashrdi3', 
+                       '$ld$hide$os10.4$___clear_cache', '$ld$hide$os10.4$___clzdi2', 
+                       '$ld$hide$os10.4$___clzsi2', '$ld$hide$os10.4$___clzti2', 
+                       '$ld$hide$os10.4$___cmpdi2', '$ld$hide$os10.4$___ctzdi2', 
+                       '$ld$hide$os10.4$___ctzsi2', '$ld$hide$os10.4$___divdc3', 
+                       '$ld$hide$os10.4$___divdi3', '$ld$hide$os10.4$___divsc3', 
+                       '$ld$hide$os10.4$___divti3', '$ld$hide$os10.4$___divxc3', 
+                       '$ld$hide$os10.4$___enable_execute_stack', '$ld$hide$os10.4$___ffsdi2', 
+                       '$ld$hide$os10.4$___fixdfdi', '$ld$hide$os10.4$___fixdfti', 
+                       '$ld$hide$os10.4$___fixsfdi', '$ld$hide$os10.4$___fixsfti', 
+                       '$ld$hide$os10.4$___fixunsdfdi', '$ld$hide$os10.4$___fixunsdfsi', 
+                       '$ld$hide$os10.4$___fixunsdfti', '$ld$hide$os10.4$___fixunssfdi', 
+                       '$ld$hide$os10.4$___fixunssfsi', '$ld$hide$os10.4$___fixunssfti', 
+                       '$ld$hide$os10.4$___fixunsxfdi', '$ld$hide$os10.4$___fixunsxfsi', 
+                       '$ld$hide$os10.4$___fixxfdi', '$ld$hide$os10.4$___floatdidf', 
+                       '$ld$hide$os10.4$___floatdisf', '$ld$hide$os10.4$___floatdixf', 
+                       '$ld$hide$os10.4$___floattidf', '$ld$hide$os10.4$___floattisf', 
+                       '$ld$hide$os10.4$___floatundidf', '$ld$hide$os10.4$___floatundisf', 
+                       '$ld$hide$os10.4$___floatundixf', '$ld$hide$os10.4$___floatuntidf', 
+                       '$ld$hide$os10.4$___floatuntisf', '$ld$hide$os10.4$___gcc_personality_v0', 
+                       '$ld$hide$os10.4$___lshrdi3', '$ld$hide$os10.4$___moddi3', 
+                       '$ld$hide$os10.4$___modti3', '$ld$hide$os10.4$___muldc3', 
+                       '$ld$hide$os10.4$___muldi3', '$ld$hide$os10.4$___mulsc3', 
+                       '$ld$hide$os10.4$___mulvdi3', '$ld$hide$os10.4$___mulvsi3', 
+                       '$ld$hide$os10.4$___mulxc3', '$ld$hide$os10.4$___negdi2', 
+                       '$ld$hide$os10.4$___negvdi2', '$ld$hide$os10.4$___negvsi2', 
+                       '$ld$hide$os10.4$___paritydi2', '$ld$hide$os10.4$___paritysi2', 
+                       '$ld$hide$os10.4$___popcountdi2', '$ld$hide$os10.4$___popcountsi2', 
+                       '$ld$hide$os10.4$___powidf2', '$ld$hide$os10.4$___powisf2', 
+                       '$ld$hide$os10.4$___powixf2', '$ld$hide$os10.4$___subvdi3', 
+                       '$ld$hide$os10.4$___subvsi3', '$ld$hide$os10.4$___ucmpdi2', 
+                       '$ld$hide$os10.4$___udivdi3', '$ld$hide$os10.4$___udivmoddi4', 
+                       '$ld$hide$os10.4$___udivmodti4', '$ld$hide$os10.4$___udivti3', 
+                       '$ld$hide$os10.4$___umoddi3', '$ld$hide$os10.4$___umodti3', 
+                       '$ld$hide$os10.5$___absvdi2', '$ld$hide$os10.5$___absvsi2', 
+                       '$ld$hide$os10.5$___addvdi3', '$ld$hide$os10.5$___addvsi3', 
+                       '$ld$hide$os10.5$___ashldi3', '$ld$hide$os10.5$___ashrdi3', 
+                       '$ld$hide$os10.5$___clear_cache', '$ld$hide$os10.5$___clzdi2', 
+                       '$ld$hide$os10.5$___clzsi2', '$ld$hide$os10.5$___clzti2', 
+                       '$ld$hide$os10.5$___cmpdi2', '$ld$hide$os10.5$___ctzdi2', 
+                       '$ld$hide$os10.5$___ctzsi2', '$ld$hide$os10.5$___divdc3', 
+                       '$ld$hide$os10.5$___divdi3', '$ld$hide$os10.5$___divsc3', 
+                       '$ld$hide$os10.5$___divti3', '$ld$hide$os10.5$___divxc3', 
+                       '$ld$hide$os10.5$___enable_execute_stack', '$ld$hide$os10.5$___ffsdi2', 
+                       '$ld$hide$os10.5$___fixdfdi', '$ld$hide$os10.5$___fixdfti', 
+                       '$ld$hide$os10.5$___fixsfdi', '$ld$hide$os10.5$___fixsfti', 
+                       '$ld$hide$os10.5$___fixunsdfdi', '$ld$hide$os10.5$___fixunsdfsi', 
+                       '$ld$hide$os10.5$___fixunsdfti', '$ld$hide$os10.5$___fixunssfdi', 
+                       '$ld$hide$os10.5$___fixunssfsi', '$ld$hide$os10.5$___fixunssfti', 
+                       '$ld$hide$os10.5$___fixunsxfdi', '$ld$hide$os10.5$___fixunsxfsi', 
+                       '$ld$hide$os10.5$___fixxfdi', '$ld$hide$os10.5$___floatdidf', 
+                       '$ld$hide$os10.5$___floatdisf', '$ld$hide$os10.5$___floatdixf', 
+                       '$ld$hide$os10.5$___floattidf', '$ld$hide$os10.5$___floattisf', 
+                       '$ld$hide$os10.5$___floatundidf', '$ld$hide$os10.5$___floatundisf', 
+                       '$ld$hide$os10.5$___floatundixf', '$ld$hide$os10.5$___floatuntidf', 
+                       '$ld$hide$os10.5$___floatuntisf', '$ld$hide$os10.5$___gcc_personality_v0', 
+                       '$ld$hide$os10.5$___lshrdi3', '$ld$hide$os10.5$___moddi3', 
+                       '$ld$hide$os10.5$___modti3', '$ld$hide$os10.5$___muldc3', 
+                       '$ld$hide$os10.5$___muldi3', '$ld$hide$os10.5$___mulsc3', 
+                       '$ld$hide$os10.5$___mulvdi3', '$ld$hide$os10.5$___mulvsi3', 
+                       '$ld$hide$os10.5$___mulxc3', '$ld$hide$os10.5$___negdi2', 
+                       '$ld$hide$os10.5$___negvdi2', '$ld$hide$os10.5$___negvsi2', 
+                       '$ld$hide$os10.5$___paritydi2', '$ld$hide$os10.5$___paritysi2', 
+                       '$ld$hide$os10.5$___popcountdi2', '$ld$hide$os10.5$___popcountsi2', 
+                       '$ld$hide$os10.5$___powidf2', '$ld$hide$os10.5$___powisf2', 
+                       '$ld$hide$os10.5$___powixf2', '$ld$hide$os10.5$___subvdi3', 
+                       '$ld$hide$os10.5$___subvsi3', '$ld$hide$os10.5$___ucmpdi2', 
+                       '$ld$hide$os10.5$___udivdi3', '$ld$hide$os10.5$___udivmoddi4', 
+                       '$ld$hide$os10.5$___udivmodti4', '$ld$hide$os10.5$___udivti3', 
+                       '$ld$hide$os10.5$___umoddi3', '$ld$hide$os10.5$___umodti3', 
+                       '$ld$hide$os10.6$___atomic_compare_exchange', '$ld$hide$os10.6$___atomic_compare_exchange_1', 
+                       '$ld$hide$os10.6$___atomic_compare_exchange_2', '$ld$hide$os10.6$___atomic_compare_exchange_4', 
+                       '$ld$hide$os10.6$___atomic_compare_exchange_8', '$ld$hide$os10.6$___atomic_exchange', 
+                       '$ld$hide$os10.6$___atomic_exchange_1', '$ld$hide$os10.6$___atomic_exchange_2', 
+                       '$ld$hide$os10.6$___atomic_exchange_4', '$ld$hide$os10.6$___atomic_exchange_8', 
+                       '$ld$hide$os10.6$___atomic_fetch_add_1', '$ld$hide$os10.6$___atomic_fetch_add_2', 
+                       '$ld$hide$os10.6$___atomic_fetch_add_4', '$ld$hide$os10.6$___atomic_fetch_add_8', 
+                       '$ld$hide$os10.6$___atomic_fetch_and_1', '$ld$hide$os10.6$___atomic_fetch_and_2', 
+                       '$ld$hide$os10.6$___atomic_fetch_and_4', '$ld$hide$os10.6$___atomic_fetch_and_8', 
+                       '$ld$hide$os10.6$___atomic_fetch_or_1', '$ld$hide$os10.6$___atomic_fetch_or_2', 
+                       '$ld$hide$os10.6$___atomic_fetch_or_4', '$ld$hide$os10.6$___atomic_fetch_or_8', 
+                       '$ld$hide$os10.6$___atomic_fetch_sub_1', '$ld$hide$os10.6$___atomic_fetch_sub_2', 
+                       '$ld$hide$os10.6$___atomic_fetch_sub_4', '$ld$hide$os10.6$___atomic_fetch_sub_8', 
+                       '$ld$hide$os10.6$___atomic_fetch_xor_1', '$ld$hide$os10.6$___atomic_fetch_xor_2', 
+                       '$ld$hide$os10.6$___atomic_fetch_xor_4', '$ld$hide$os10.6$___atomic_fetch_xor_8', 
+                       '$ld$hide$os10.6$___atomic_load', '$ld$hide$os10.6$___atomic_load_1', 
+                       '$ld$hide$os10.6$___atomic_load_2', '$ld$hide$os10.6$___atomic_load_4', 
+                       '$ld$hide$os10.6$___atomic_load_8', '$ld$hide$os10.6$___atomic_store', 
+                       '$ld$hide$os10.6$___atomic_store_1', '$ld$hide$os10.6$___atomic_store_2', 
+                       '$ld$hide$os10.6$___atomic_store_4', '$ld$hide$os10.6$___atomic_store_8', 
+                       '$ld$hide$os10.6$___chkstk_darwin', '$ld$hide$os10.6$___extendhfsf2', 
+                       '$ld$hide$os10.6$___truncdfhf2', '$ld$hide$os10.6$___truncsfhf2', 
+                       '$ld$hide$os10.6$_atomic_flag_clear', '$ld$hide$os10.6$_atomic_flag_clear_explicit', 
+                       '$ld$hide$os10.6$_atomic_flag_test_and_set', '$ld$hide$os10.6$_atomic_flag_test_and_set_explicit', 
+                       '$ld$hide$os10.6$_atomic_signal_fence', '$ld$hide$os10.6$_atomic_thread_fence', 
+                       '$ld$hide$os10.7$___atomic_compare_exchange', '$ld$hide$os10.7$___atomic_compare_exchange_1', 
+                       '$ld$hide$os10.7$___atomic_compare_exchange_2', '$ld$hide$os10.7$___atomic_compare_exchange_4', 
+                       '$ld$hide$os10.7$___atomic_compare_exchange_8', '$ld$hide$os10.7$___atomic_exchange', 
+                       '$ld$hide$os10.7$___atomic_exchange_1', '$ld$hide$os10.7$___atomic_exchange_2', 
+                       '$ld$hide$os10.7$___atomic_exchange_4', '$ld$hide$os10.7$___atomic_exchange_8', 
+                       '$ld$hide$os10.7$___atomic_fetch_add_1', '$ld$hide$os10.7$___atomic_fetch_add_2', 
+                       '$ld$hide$os10.7$___atomic_fetch_add_4', '$ld$hide$os10.7$___atomic_fetch_add_8', 
+                       '$ld$hide$os10.7$___atomic_fetch_and_1', '$ld$hide$os10.7$___atomic_fetch_and_2', 
+                       '$ld$hide$os10.7$___atomic_fetch_and_4', '$ld$hide$os10.7$___atomic_fetch_and_8', 
+                       '$ld$hide$os10.7$___atomic_fetch_or_1', '$ld$hide$os10.7$___atomic_fetch_or_2', 
+                       '$ld$hide$os10.7$___atomic_fetch_or_4', '$ld$hide$os10.7$___atomic_fetch_or_8', 
+                       '$ld$hide$os10.7$___atomic_fetch_sub_1', '$ld$hide$os10.7$___atomic_fetch_sub_2', 
+                       '$ld$hide$os10.7$___atomic_fetch_sub_4', '$ld$hide$os10.7$___atomic_fetch_sub_8', 
+                       '$ld$hide$os10.7$___atomic_fetch_xor_1', '$ld$hide$os10.7$___atomic_fetch_xor_2', 
+                       '$ld$hide$os10.7$___atomic_fetch_xor_4', '$ld$hide$os10.7$___atomic_fetch_xor_8', 
+                       '$ld$hide$os10.7$___atomic_load', '$ld$hide$os10.7$___atomic_load_1', 
+                       '$ld$hide$os10.7$___atomic_load_2', '$ld$hide$os10.7$___atomic_load_4', 
+                       '$ld$hide$os10.7$___atomic_load_8', '$ld$hide$os10.7$___atomic_store', 
+                       '$ld$hide$os10.7$___atomic_store_1', '$ld$hide$os10.7$___atomic_store_2', 
+                       '$ld$hide$os10.7$___atomic_store_4', '$ld$hide$os10.7$___atomic_store_8', 
+                       '$ld$hide$os10.7$___chkstk_darwin', '$ld$hide$os10.7$___extendhfsf2', 
+                       '$ld$hide$os10.7$___truncdfhf2', '$ld$hide$os10.7$___truncsfhf2', 
+                       '$ld$hide$os10.7$_atomic_flag_clear', '$ld$hide$os10.7$_atomic_flag_clear_explicit', 
+                       '$ld$hide$os10.7$_atomic_flag_test_and_set', '$ld$hide$os10.7$_atomic_flag_test_and_set_explicit', 
+                       '$ld$hide$os10.7$_atomic_signal_fence', '$ld$hide$os10.7$_atomic_thread_fence', 
+                       '$ld$hide$os10.8$___atomic_compare_exchange', '$ld$hide$os10.8$___atomic_compare_exchange_1', 
+                       '$ld$hide$os10.8$___atomic_compare_exchange_2', '$ld$hide$os10.8$___atomic_compare_exchange_4', 
+                       '$ld$hide$os10.8$___atomic_compare_exchange_8', '$ld$hide$os10.8$___atomic_exchange', 
+                       '$ld$hide$os10.8$___atomic_exchange_1', '$ld$hide$os10.8$___atomic_exchange_2', 
+                       '$ld$hide$os10.8$___atomic_exchange_4', '$ld$hide$os10.8$___atomic_exchange_8', 
+                       '$ld$hide$os10.8$___atomic_fetch_add_1', '$ld$hide$os10.8$___atomic_fetch_add_2', 
+                       '$ld$hide$os10.8$___atomic_fetch_add_4', '$ld$hide$os10.8$___atomic_fetch_add_8', 
+                       '$ld$hide$os10.8$___atomic_fetch_and_1', '$ld$hide$os10.8$___atomic_fetch_and_2', 
+                       '$ld$hide$os10.8$___atomic_fetch_and_4', '$ld$hide$os10.8$___atomic_fetch_and_8', 
+                       '$ld$hide$os10.8$___atomic_fetch_or_1', '$ld$hide$os10.8$___atomic_fetch_or_2', 
+                       '$ld$hide$os10.8$___atomic_fetch_or_4', '$ld$hide$os10.8$___atomic_fetch_or_8', 
+                       '$ld$hide$os10.8$___atomic_fetch_sub_1', '$ld$hide$os10.8$___atomic_fetch_sub_2', 
+                       '$ld$hide$os10.8$___atomic_fetch_sub_4', '$ld$hide$os10.8$___atomic_fetch_sub_8', 
+                       '$ld$hide$os10.8$___atomic_fetch_xor_1', '$ld$hide$os10.8$___atomic_fetch_xor_2', 
+                       '$ld$hide$os10.8$___atomic_fetch_xor_4', '$ld$hide$os10.8$___atomic_fetch_xor_8', 
+                       '$ld$hide$os10.8$___atomic_load', '$ld$hide$os10.8$___atomic_load_1', 
+                       '$ld$hide$os10.8$___atomic_load_2', '$ld$hide$os10.8$___atomic_load_4', 
+                       '$ld$hide$os10.8$___atomic_load_8', '$ld$hide$os10.8$___atomic_store', 
+                       '$ld$hide$os10.8$___atomic_store_1', '$ld$hide$os10.8$___atomic_store_2', 
+                       '$ld$hide$os10.8$___atomic_store_4', '$ld$hide$os10.8$___atomic_store_8', 
+                       '$ld$hide$os10.8$___chkstk_darwin', '$ld$hide$os10.8$___extendhfsf2', 
+                       '$ld$hide$os10.8$___truncdfhf2', '$ld$hide$os10.8$___truncsfhf2', 
+                       '$ld$hide$os10.8$_atomic_flag_clear', '$ld$hide$os10.8$_atomic_flag_clear_explicit', 
+                       '$ld$hide$os10.8$_atomic_flag_test_and_set', '$ld$hide$os10.8$_atomic_flag_test_and_set_explicit', 
+                       '$ld$hide$os10.8$_atomic_signal_fence', '$ld$hide$os10.8$_atomic_thread_fence', 
+                       '$ld$hide$os10.9$___chkstk_darwin', '$ld$hide$os10.9$___extendhfsf2', 
+                       '$ld$hide$os10.9$___truncdfhf2', '$ld$hide$os10.9$___truncsfhf2', 
+                       '$ld$hide$os10.9$_atomic_flag_clear', '$ld$hide$os10.9$_atomic_flag_clear_explicit', 
+                       '$ld$hide$os10.9$_atomic_flag_test_and_set', '$ld$hide$os10.9$_atomic_flag_test_and_set_explicit', 
+                       '$ld$hide$os10.9$_atomic_signal_fence', '$ld$hide$os10.9$_atomic_thread_fence', 
+                       ___atomic_compare_exchange, ___atomic_compare_exchange_1, 
+                       ___atomic_compare_exchange_2, ___atomic_compare_exchange_4, 
+                       ___atomic_compare_exchange_8, ___atomic_exchange, ___atomic_exchange_1, 
+                       ___atomic_exchange_2, ___atomic_exchange_4, ___atomic_exchange_8, 
+                       ___atomic_fetch_add_1, ___atomic_fetch_add_2, ___atomic_fetch_add_4, 
+                       ___atomic_fetch_add_8, ___atomic_fetch_and_1, ___atomic_fetch_and_2, 
+                       ___atomic_fetch_and_4, ___atomic_fetch_and_8, ___atomic_fetch_or_1, 
+                       ___atomic_fetch_or_2, ___atomic_fetch_or_4, ___atomic_fetch_or_8, 
+                       ___atomic_fetch_sub_1, ___atomic_fetch_sub_2, ___atomic_fetch_sub_4, 
+                       ___atomic_fetch_sub_8, ___atomic_fetch_xor_1, ___atomic_fetch_xor_2, 
+                       ___atomic_fetch_xor_4, ___atomic_fetch_xor_8, ___atomic_is_lock_free, 
+                       ___atomic_load, ___atomic_load_1, ___atomic_load_2, ___atomic_load_4, 
+                       ___atomic_load_8, ___atomic_store, ___atomic_store_1, ___atomic_store_2, 
+                       ___atomic_store_4, ___atomic_store_8, ___chkstk_darwin, ___clear_cache, 
+                       ___clzti2, ___divti3, ___enable_execute_stack, ___extendhfsf2, 
+                       ___fixdfti, ___fixsfti, ___fixunsdfti, ___fixunssfti, ___floattidf, 
+                       ___floattisf, ___floatuntidf, ___floatuntisf, ___gcc_personality_v0, 
+                       ___gnu_f2h_ieee, ___gnu_h2f_ieee, ___modti3, ___muldc3, ___mulsc3, 
+                       ___powidf2, ___powisf2, ___truncdfhf2, ___truncsfhf2, ___udivmodti4, 
+                       ___udivti3, ___umodti3, _atomic_flag_clear, _atomic_flag_clear_explicit, 
+                       _atomic_flag_test_and_set, _atomic_flag_test_and_set_explicit, 
+                       _atomic_signal_fence, _atomic_thread_fence ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           0CD59665-DEA3-3995-84BC-485D4EA42680
+  - target:          x86_64-maccatalyst
+    value:           0CD59665-DEA3-3995-84BC-485D4EA42680
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           79AD0FC1-4F88-3589-A602-45F2AA482B59
+  - target:          arm64e-maccatalyst
+    value:           79AD0FC1-4F88-3589-A602-45F2AA482B59
+install-name:    '/usr/lib/system/libcopyfile.dylib'
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _copyfile, _copyfile_state_alloc, _copyfile_state_free, _copyfile_state_get, 
+                       _copyfile_state_set, _fcopyfile, _xattr_flags_from_name, _xattr_intent_with_flags, 
+                       _xattr_name_with_flags, _xattr_name_without_flags, _xattr_preserve_for_intent ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           D198406D-6F0D-3857-9CB3-9BA231DFEE00
+  - target:          x86_64-maccatalyst
+    value:           D198406D-6F0D-3857-9CB3-9BA231DFEE00
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           6A5FFEB0-E606-324E-B687-DA95C362CE05
+  - target:          arm64e-maccatalyst
+    value:           6A5FFEB0-E606-324E-B687-DA95C362CE05
+install-name:    '/usr/lib/system/libcorecrypto.dylib'
+current-version: 1386.40.5
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
+    symbols:         [ _ccaes_intel_cbc_decrypt_aesni_mode, _ccaes_intel_cbc_decrypt_opt_mode, 
+                       _ccaes_intel_cbc_encrypt_aesni_mode, _ccaes_intel_cbc_encrypt_opt_mode, 
+                       _ccaes_intel_ecb_decrypt_aesni_mode, _ccaes_intel_ecb_decrypt_opt_mode, 
+                       _ccaes_intel_ecb_encrypt_aesni_mode, _ccaes_intel_ecb_encrypt_opt_mode, 
+                       _ccaes_intel_xts_decrypt_aesni_mode, _ccaes_intel_xts_decrypt_opt_mode, 
+                       _ccaes_intel_xts_encrypt_aesni_mode, _ccaes_intel_xts_encrypt_opt_mode, 
+                       _ccsha1_vng_intel_SupplementalSSE3_di, _ccsha224_vng_intel_SupplementalSSE3_di, 
+                       _ccsha256_vng_intel_SupplementalSSE3_di ]
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _CCEC_FAULT_CANARY, _CCRSA_PKCS1_FAULT_CANARY, _CCRSA_PSS_FAULT_CANARY, 
+                       _CCSS_PRIME_P192, _CCSS_PRIME_P224, _CCSS_PRIME_P256, _CCSS_PRIME_P384, 
+                       _CCSS_PRIME_P521, _cc_abort, _cc_atfork_child, _cc_atfork_parent, 
+                       _cc_atfork_prepare, _cc_clear, _cc_cmp_safe, _cc_impl_name, 
+                       _cc_try_abort, _cc_try_abort_if, _ccaes_cbc_decrypt_mode, 
+                       _ccaes_cbc_encrypt_mode, _ccaes_ccm_decrypt_mode, _ccaes_ccm_encrypt_mode, 
+                       _ccaes_cfb8_decrypt_mode, _ccaes_cfb8_encrypt_mode, _ccaes_cfb_decrypt_mode, 
+                       _ccaes_cfb_encrypt_mode, _ccaes_ctr_crypt_mode, _ccaes_ecb_decrypt_mode, 
+                       _ccaes_ecb_encrypt_mode, _ccaes_gcm_decrypt_mode, _ccaes_gcm_encrypt_mode, 
+                       _ccaes_gladman_cbc_decrypt_mode, _ccaes_gladman_cbc_encrypt_mode, 
+                       _ccaes_ltc_ecb_decrypt_mode, _ccaes_ltc_ecb_encrypt_mode, 
+                       _ccaes_ofb_crypt_mode, _ccaes_siv_decrypt_mode, _ccaes_siv_encrypt_mode, 
+                       _ccaes_siv_hmac_sha256_decrypt_mode, _ccaes_siv_hmac_sha256_encrypt_mode, 
+                       _ccaes_unwind, _ccaes_xts_decrypt_mode, _ccaes_xts_encrypt_mode, 
+                       _ccansikdf_x963, _ccapsic_client_check_intersect_response, 
+                       _ccapsic_client_generate_match_response, _ccapsic_client_init, 
+                       _ccapsic_client_state_sizeof, _ccapsic_server_determine_intersection, 
+                       _ccapsic_server_encode_element, _ccapsic_server_init, _ccapsic_server_state_sizeof, 
+                       _ccblowfish_cbc_decrypt_mode, _ccblowfish_cbc_encrypt_mode, 
+                       _ccblowfish_cfb8_decrypt_mode, _ccblowfish_cfb8_encrypt_mode, 
+                       _ccblowfish_cfb_decrypt_mode, _ccblowfish_cfb_encrypt_mode, 
+                       _ccblowfish_ctr_crypt_mode, _ccblowfish_ecb_decrypt_mode, 
+                       _ccblowfish_ecb_encrypt_mode, _ccblowfish_ofb_crypt_mode, 
+                       _cccast_cbc_decrypt_mode, _cccast_cbc_encrypt_mode, _cccast_cfb8_decrypt_mode, 
+                       _cccast_cfb8_encrypt_mode, _cccast_cfb_decrypt_mode, _cccast_cfb_encrypt_mode, 
+                       _cccast_ctr_crypt_mode, _cccast_ecb_decrypt_mode, _cccast_ecb_encrypt_mode, 
+                       _cccast_ofb_crypt_mode, _cccbc_block_size, _cccbc_clear_iv, 
+                       _cccbc_context_size, _cccbc_copy_iv, _cccbc_init, _cccbc_one_shot, 
+                       _cccbc_set_iv, _cccbc_update, _ccccm_aad, _ccccm_block_size, 
+                       _ccccm_cbcmac, _ccccm_context_size, _ccccm_decrypt, _ccccm_encrypt, 
+                       _ccccm_finalize, _ccccm_finalize_and_generate_tag, _ccccm_finalize_and_verify_tag, 
+                       _ccccm_init, _ccccm_one_shot, _ccccm_one_shot_decrypt, _ccccm_one_shot_encrypt, 
+                       _ccccm_reset, _ccccm_set_iv, _ccccm_update, _cccfb8_block_size, 
+                       _cccfb8_context_size, _cccfb8_init, _cccfb8_one_shot, _cccfb8_update, 
+                       _cccfb_block_size, _cccfb_context_size, _cccfb_init, _cccfb_one_shot, 
+                       _cccfb_update, _ccchacha20, _ccchacha20_final, _ccchacha20_init, 
+                       _ccchacha20_reset, _ccchacha20_setcounter, _ccchacha20_setnonce, 
+                       _ccchacha20_update, _ccchacha20poly1305_aad, _ccchacha20poly1305_decrypt, 
+                       _ccchacha20poly1305_decrypt_oneshot, _ccchacha20poly1305_encrypt, 
+                       _ccchacha20poly1305_encrypt_oneshot, _ccchacha20poly1305_finalize, 
+                       _ccchacha20poly1305_incnonce, _ccchacha20poly1305_info, _ccchacha20poly1305_init, 
+                       _ccchacha20poly1305_reset, _ccchacha20poly1305_setnonce, _ccchacha20poly1305_verify, 
+                       _ccckg_contributor_commit, _ccckg_contributor_finish, _ccckg_init, 
+                       _ccckg_owner_finish, _ccckg_owner_generate_share, _ccckg_sizeof_commitment, 
+                       _ccckg_sizeof_ctx, _ccckg_sizeof_opening, _ccckg_sizeof_share, 
+                       _cccmac_final_generate, _cccmac_final_verify, _cccmac_init, 
+                       _cccmac_one_shot_generate, _cccmac_one_shot_verify, _cccmac_update, 
+                       _ccctr_block_size, _ccctr_context_size, _ccctr_init, _ccctr_one_shot, 
+                       _ccctr_update, _cccurve25519, _ccder_blob_decode_bitstring, 
+                       _ccder_blob_decode_eckey, _ccder_blob_decode_len, _ccder_blob_decode_len_strict, 
+                       _ccder_blob_decode_oid, _ccder_blob_decode_range, _ccder_blob_decode_range_strict, 
+                       _ccder_blob_decode_seqii, _ccder_blob_decode_seqii_strict, 
+                       _ccder_blob_decode_sequence_tl, _ccder_blob_decode_sequence_tl_strict, 
+                       _ccder_blob_decode_tag, _ccder_blob_decode_tl, _ccder_blob_decode_tl_strict, 
+                       _ccder_blob_decode_uint, _ccder_blob_decode_uint64, _ccder_blob_decode_uint_n, 
+                       _ccder_blob_decode_uint_strict, _ccder_blob_encode_body, _ccder_blob_encode_body_tl, 
+                       _ccder_blob_encode_eckey, _ccder_blob_encode_implicit_integer, 
+                       _ccder_blob_encode_implicit_octet_string, _ccder_blob_encode_implicit_raw_octet_string, 
+                       _ccder_blob_encode_implicit_uint64, _ccder_blob_encode_integer, 
+                       _ccder_blob_encode_len, _ccder_blob_encode_octet_string, _ccder_blob_encode_oid, 
+                       _ccder_blob_encode_raw_octet_string, _ccder_blob_encode_tag, 
+                       _ccder_blob_encode_tl, _ccder_blob_encode_uint64, _ccder_blob_reserve, 
+                       _ccder_blob_reserve_tl, _ccder_decode_bitstring, _ccder_decode_constructed_tl, 
+                       _ccder_decode_constructed_tl_strict, _ccder_decode_dhparam_n, 
+                       _ccder_decode_dhparams, _ccder_decode_eckey, _ccder_decode_len, 
+                       _ccder_decode_len_strict, _ccder_decode_oid, _ccder_decode_rsa_priv, 
+                       _ccder_decode_rsa_priv_n, _ccder_decode_rsa_pub, _ccder_decode_rsa_pub_n, 
+                       _ccder_decode_rsa_pub_x509, _ccder_decode_rsa_pub_x509_n, 
+                       _ccder_decode_seqii, _ccder_decode_seqii_strict, _ccder_decode_sequence_tl, 
+                       _ccder_decode_sequence_tl_strict, _ccder_decode_tag, _ccder_decode_tl, 
+                       _ccder_decode_tl_strict, _ccder_decode_uint, _ccder_decode_uint64, 
+                       _ccder_decode_uint_n, _ccder_decode_uint_strict, _ccder_encode_body, 
+                       _ccder_encode_body_nocopy, _ccder_encode_constructed_tl, _ccder_encode_dhparams, 
+                       _ccder_encode_dhparams_size, _ccder_encode_eckey, _ccder_encode_eckey_size, 
+                       _ccder_encode_implicit_integer, _ccder_encode_implicit_octet_string, 
+                       _ccder_encode_implicit_raw_octet_string, _ccder_encode_implicit_uint64, 
+                       _ccder_encode_integer, _ccder_encode_len, _ccder_encode_octet_string, 
+                       _ccder_encode_oid, _ccder_encode_raw_octet_string, _ccder_encode_rsa_priv, 
+                       _ccder_encode_rsa_priv_size, _ccder_encode_rsa_pub, _ccder_encode_rsa_pub_size, 
+                       _ccder_encode_tag, _ccder_encode_tl, _ccder_encode_uint64, 
+                       _ccder_sizeof, _ccder_sizeof_eckey, _ccder_sizeof_implicit_integer, 
+                       _ccder_sizeof_implicit_octet_string, _ccder_sizeof_implicit_raw_octet_string, 
+                       _ccder_sizeof_implicit_uint64, _ccder_sizeof_integer, _ccder_sizeof_len, 
+                       _ccder_sizeof_octet_string, _ccder_sizeof_oid, _ccder_sizeof_raw_octet_string, 
+                       _ccder_sizeof_tag, _ccder_sizeof_uint64, _ccdes3_cbc_decrypt_mode, 
+                       _ccdes3_cbc_encrypt_mode, _ccdes3_cfb8_decrypt_mode, _ccdes3_cfb8_encrypt_mode, 
+                       _ccdes3_cfb_decrypt_mode, _ccdes3_cfb_encrypt_mode, _ccdes3_ctr_crypt_mode, 
+                       _ccdes3_ecb_decrypt_mode, _ccdes3_ecb_encrypt_mode, _ccdes3_ltc_ecb_decrypt_mode, 
+                       _ccdes3_ltc_ecb_encrypt_mode, _ccdes3_ofb_crypt_mode, _ccdes_cbc_cksum, 
+                       _ccdes_cbc_decrypt_mode, _ccdes_cbc_encrypt_mode, _ccdes_cfb8_decrypt_mode, 
+                       _ccdes_cfb8_encrypt_mode, _ccdes_cfb_decrypt_mode, _ccdes_cfb_encrypt_mode, 
+                       _ccdes_ctr_crypt_mode, _ccdes_ecb_decrypt_mode, _ccdes_ecb_encrypt_mode, 
+                       _ccdes_key_is_weak, _ccdes_key_set_odd_parity, _ccdes_ofb_crypt_mode, 
+                       _ccdh_compute_shared_secret, _ccdh_export_pub, _ccdh_generate_key, 
+                       _ccdh_gp_apple768, _ccdh_gp_rfc2409group02, _ccdh_gp_rfc3526group05, 
+                       _ccdh_gp_rfc3526group14, _ccdh_gp_rfc3526group15, _ccdh_gp_rfc3526group16, 
+                       _ccdh_gp_rfc3526group17, _ccdh_gp_rfc3526group18, _ccdh_gp_rfc5114_MODP_1024_160, 
+                       _ccdh_gp_rfc5114_MODP_2048_224, _ccdh_gp_rfc5114_MODP_2048_256, 
+                       _ccdh_gp_size, _ccdh_import_full, _ccdh_import_priv, _ccdh_import_pub, 
+                       _ccdh_init_gp_from_bytes, _ccdh_init_safe_gp_from_bytes, _ccdigest, 
+                       _ccdigest_init, _ccdigest_oid_lookup, _ccdigest_update, _ccdrbg_df_bc_init, 
+                       _ccdrbg_factory_nistctr, _ccdrbg_factory_nisthmac, _ccdrbg_must_reseed, 
+                       _ccec_affinify, _ccec_blind, _ccec_compact_export, _ccec_compact_export_pub, 
+                       _ccec_compact_generate_key, _ccec_compact_generate_key_init, 
+                       _ccec_compact_generate_key_step, _ccec_compact_import_priv, 
+                       _ccec_compact_import_priv_size, _ccec_compact_import_pub, 
+                       _ccec_compact_import_pub_size, _ccec_compact_transform_key, 
+                       _ccec_compressed_x962_export_pub, _ccec_compressed_x962_export_pub_size, 
+                       _ccec_compressed_x962_import_pub, _ccec_compute_key, _ccec_cp_192, 
+                       _ccec_cp_224, _ccec_cp_256, _ccec_cp_384, _ccec_cp_521, _ccec_curve_for_length_lookup, 
+                       _ccec_der_export_diversified_pub, _ccec_der_export_diversified_pub_size, 
+                       _ccec_der_export_priv, _ccec_der_export_priv_size, _ccec_der_import_diversified_pub, 
+                       _ccec_der_import_priv, _ccec_der_import_priv_keytype, _ccec_diversify_min_entropy_len, 
+                       _ccec_diversify_priv_twin, _ccec_diversify_pub, _ccec_diversify_pub_twin, 
+                       _ccec_export_affine_point, _ccec_export_affine_point_size, 
+                       _ccec_export_pub, _ccec_extract_rs, _ccec_full_add, _ccec_generate_blinding_keys, 
+                       _ccec_generate_key, _ccec_generate_key_deterministic, _ccec_generate_key_fips, 
+                       _ccec_generate_key_legacy, _ccec_generate_scalar_fips_retry, 
+                       _ccec_get_cp, _ccec_get_fullkey_components, _ccec_get_pubkey_components, 
+                       _ccec_import_affine_point, _ccec_import_pub, _ccec_is_compactable_pub, 
+                       _ccec_keysize_is_supported, _ccec_make_priv, _ccec_make_pub, 
+                       _ccec_mult_blinded, _ccec_pairwise_consistency_check, _ccec_print_full_key, 
+                       _ccec_print_public_key, _ccec_projectify, _ccec_raw_import_priv_only, 
+                       _ccec_raw_import_pub, _ccec_rfc6637_dh_curve_p256, _ccec_rfc6637_dh_curve_p521, 
+                       _ccec_rfc6637_unwrap_key, _ccec_rfc6637_unwrap_sha256_kek_aes128, 
+                       _ccec_rfc6637_unwrap_sha512_kek_aes256, _ccec_rfc6637_wrap_key, 
+                       _ccec_rfc6637_wrap_key_diversified, _ccec_rfc6637_wrap_key_size, 
+                       _ccec_rfc6637_wrap_sha256_kek_aes128, _ccec_rfc6637_wrap_sha512_kek_aes256, 
+                       _ccec_sign, _ccec_sign_composite, _ccec_sign_composite_msg, 
+                       _ccec_sign_msg, _ccec_signature_r_s_size, _ccec_unblind, _ccec_validate_pub, 
+                       _ccec_verify, _ccec_verify_composite, _ccec_verify_composite_digest, 
+                       _ccec_verify_composite_msg, _ccec_verify_digest, _ccec_verify_msg, 
+                       _ccec_x963_export, _ccec_x963_import_priv, _ccec_x963_import_priv_size, 
+                       _ccec_x963_import_pub, _ccec_x963_import_pub_size, _ccecb_block_size, 
+                       _ccecb_context_size, _ccecb_init, _ccecb_one_shot, _ccecb_update, 
+                       _ccecdh_compute_shared_secret, _ccecdh_generate_key, _ccecies_decrypt_gcm, 
+                       _ccecies_decrypt_gcm_composite, _ccecies_decrypt_gcm_from_shared_secret, 
+                       _ccecies_decrypt_gcm_plaintext_size, _ccecies_decrypt_gcm_plaintext_size_cp, 
+                       _ccecies_decrypt_gcm_setup, _ccecies_encrypt_gcm, _ccecies_encrypt_gcm_ciphertext_size, 
+                       _ccecies_encrypt_gcm_composite, _ccecies_encrypt_gcm_from_shared_secret, 
+                       _ccecies_encrypt_gcm_setup, _ccecies_import_eph_pub, _ccecies_pub_key_size, 
+                       _ccecies_pub_key_size_cp, _cced25519_make_key_pair, _cced25519_make_pub, 
+                       _cced25519_sign, _cced25519_verify, _ccentropy_add_entropy, 
+                       _ccentropy_digest_init, _ccentropy_get_seed, _ccentropy_rng_init, 
+                       _ccgcm_aad, _ccgcm_block_size, _ccgcm_context_size, _ccgcm_finalize, 
+                       _ccgcm_gmac, _ccgcm_inc_iv, _ccgcm_init, _ccgcm_init_with_iv, 
+                       _ccgcm_one_shot, _ccgcm_one_shot_legacy, _ccgcm_reset, _ccgcm_set_iv, 
+                       _ccgcm_set_iv_legacy, _ccgcm_update, _cch2c, _cch2c_name, 
+                       _cch2c_p256_sha256_sae_compat_info, _cch2c_p256_sha256_sswu_ro_info, 
+                       _cch2c_p384_sha512_sswu_ro_info, _cch2c_p521_sha512_sswu_ro_info, 
+                       _cchkdf, _cchkdf_expand, _cchkdf_extract, _cchmac, _cchmac_final, 
+                       _cchmac_init, _cchmac_update, _cchpke_initiator_encrypt, _cchpke_initiator_export, 
+                       _cchpke_initiator_seal, _cchpke_initiator_setup, _cchpke_kem_generate_key_pair, 
+                       _cchpke_params_sizeof_aead_key, _cchpke_params_sizeof_aead_nonce, 
+                       _cchpke_params_sizeof_aead_tag, _cchpke_params_sizeof_kdf_hash, 
+                       _cchpke_params_sizeof_kem_enc, _cchpke_params_sizeof_kem_pk, 
+                       _cchpke_params_sizeof_kem_pk_marshalled, _cchpke_params_sizeof_kem_shared_secret, 
+                       _cchpke_params_sizeof_kem_sk, _cchpke_params_x25519_AESGCM128_HKDF_SHA256, 
+                       _cchpke_responder_decrypt, _cchpke_responder_export, _cchpke_responder_open, 
+                       _cchpke_responder_setup, _ccmd2_ltc_di, _ccmd4_ltc_di, _ccmd5_di, 
+                       _ccmd5_ltc_di, _ccmgf, _ccmode_factory_cbc_decrypt, _ccmode_factory_cbc_encrypt, 
+                       _ccmode_factory_ccm_decrypt, _ccmode_factory_ccm_encrypt, 
+                       _ccmode_factory_cfb8_decrypt, _ccmode_factory_cfb8_encrypt, 
+                       _ccmode_factory_cfb_decrypt, _ccmode_factory_cfb_encrypt, 
+                       _ccmode_factory_ctr_crypt, _ccmode_factory_gcm_decrypt, _ccmode_factory_gcm_encrypt, 
+                       _ccmode_factory_ofb_crypt, _ccmode_factory_omac_decrypt, _ccmode_factory_omac_encrypt, 
+                       _ccmode_factory_siv_decrypt, _ccmode_factory_siv_encrypt, 
+                       _ccmode_factory_xts_decrypt, _ccmode_factory_xts_encrypt, 
+                       _ccn_add, _ccn_add1, _ccn_bitlen, _ccn_cmp, _ccn_cmpn, _ccn_lprint, 
+                       _ccn_print, _ccn_read_uint, _ccn_set, _ccn_shift_right, _ccn_sub, 
+                       _ccn_write_int, _ccn_write_int_size, _ccn_write_uint, _ccn_write_uint_padded_ct, 
+                       _ccn_write_uint_size, _ccnistkdf_ctr_cmac, _ccnistkdf_ctr_cmac_fixed, 
+                       _ccnistkdf_ctr_hmac, _ccnistkdf_ctr_hmac_fixed, _ccnistkdf_fb_hmac, 
+                       _ccnistkdf_fb_hmac_fixed, _ccofb_block_size, _ccofb_context_size, 
+                       _ccofb_init, _ccofb_one_shot, _ccofb_update, _ccoid_equal, 
+                       _ccomac_block_size, _ccomac_context_size, _ccomac_init, _ccomac_one_shot, 
+                       _ccomac_update, _ccpad_cts1_decrypt, _ccpad_cts1_encrypt, 
+                       _ccpad_cts2_decrypt, _ccpad_cts2_encrypt, _ccpad_cts3_decrypt, 
+                       _ccpad_cts3_encrypt, _ccpad_pkcs7_decode, _ccpad_pkcs7_decrypt, 
+                       _ccpad_pkcs7_ecb_decrypt, _ccpad_pkcs7_ecb_encrypt, _ccpad_pkcs7_encrypt, 
+                       _ccpad_xts_decrypt, _ccpad_xts_encrypt, _ccpbkdf2_hmac, _ccpoly1305, 
+                       _ccpoly1305_final, _ccpoly1305_init, _ccpoly1305_update, _ccrc2_cbc_decrypt_mode, 
+                       _ccrc2_cbc_encrypt_mode, _ccrc2_cfb8_decrypt_mode, _ccrc2_cfb8_encrypt_mode, 
+                       _ccrc2_cfb_decrypt_mode, _ccrc2_cfb_encrypt_mode, _ccrc2_ctr_crypt_mode, 
+                       _ccrc2_ecb_decrypt_mode, _ccrc2_ecb_encrypt_mode, _ccrc2_ofb_crypt_mode, 
+                       _ccrc4, _ccrc4_eay, _ccrmd160_ltc_di, _ccrng, _ccrng_drbg_done, 
+                       _ccrng_drbg_init, _ccrng_drbg_init_withdrbg, _ccrng_drbg_reseed, 
+                       _ccrng_ecfips_test_init, _ccrng_pbkdf2_prng_init, _ccrng_prng, 
+                       _ccrng_rsafips_test_init, _ccrng_rsafips_test_set_next, _ccrng_sequence_init, 
+                       _ccrng_system_done, _ccrng_system_init, _ccrng_test_done, 
+                       _ccrng_test_init, _ccrng_trng, _ccrng_uniform, _ccrsa_decrypt_eme_pkcs1v15, 
+                       _ccrsa_decrypt_oaep, _ccrsa_dump_full_key, _ccrsa_dump_public_key, 
+                       _ccrsa_eme_pkcs1v15_decode, _ccrsa_eme_pkcs1v15_encode, _ccrsa_emsa_pkcs1v15_encode, 
+                       _ccrsa_emsa_pkcs1v15_verify, _ccrsa_emsa_pss_decode, _ccrsa_emsa_pss_encode, 
+                       _ccrsa_encrypt_eme_pkcs1v15, _ccrsa_encrypt_oaep, _ccrsa_export_pub, 
+                       _ccrsa_generate_fips186_key, _ccrsa_generate_key, _ccrsa_generate_key_deterministic, 
+                       _ccrsa_get_fullkey_components, _ccrsa_get_pubkey_components, 
+                       _ccrsa_import_pub, _ccrsa_init_pub, _ccrsa_make_priv, _ccrsa_make_pub, 
+                       _ccrsa_oaep_decode_parameter, _ccrsa_oaep_encode_parameter, 
+                       _ccrsa_priv_crypt, _ccrsa_pub_crypt, _ccrsa_pubkeylength, 
+                       _ccrsa_recover_priv, _ccrsa_sign_pkcs1v15, _ccrsa_sign_pkcs1v15_msg, 
+                       _ccrsa_sign_pss, _ccrsa_sign_pss_msg, _ccrsa_verify_pkcs1v15, 
+                       _ccrsa_verify_pkcs1v15_allowshortsigs, _ccrsa_verify_pkcs1v15_digest, 
+                       _ccrsa_verify_pkcs1v15_msg, _ccrsa_verify_pss_digest, _ccrsa_verify_pss_msg, 
+                       _ccrsabssa_blind_message, _ccrsabssa_ciphersuite_rsa2048_sha384, 
+                       _ccrsabssa_ciphersuite_rsa3072_sha384, _ccrsabssa_ciphersuite_rsa4096_sha384, 
+                       _ccrsabssa_sign_blinded_message, _ccrsabssa_unblind_signature, 
+                       _ccsae_gen_kck_and_pmk, _ccsae_gen_password_value, _ccsae_generate_commitment, 
+                       _ccsae_generate_commitment_finalize, _ccsae_generate_commitment_init, 
+                       _ccsae_generate_commitment_partial, _ccsae_generate_confirmation, 
+                       _ccsae_generate_h2c_commit, _ccsae_generate_h2c_commit_finalize, 
+                       _ccsae_generate_h2c_commit_init, _ccsae_generate_h2c_pt, _ccsae_get_keys, 
+                       _ccsae_init, _ccsae_init_p256_sha256, _ccsae_lexographic_order_key, 
+                       _ccsae_sizeof_commitment, _ccsae_sizeof_confirmation, _ccsae_sizeof_ctx, 
+                       _ccsae_sizeof_pt, _ccsae_verify_commitment, _ccsae_verify_confirmation, 
+                       _ccscrypt, _ccscrypt_storage_size, _ccsha1_di, _ccsha1_eay_di, 
+                       _ccsha1_ltc_di, _ccsha224_di, _ccsha224_ltc_di, _ccsha256_di, 
+                       _ccsha256_ltc_di, _ccsha384_di, _ccsha384_ltc_di, _ccsha3_224_c_di, 
+                       _ccsha3_224_di, _ccsha3_256_c_di, _ccsha3_256_di, _ccsha3_384_c_di, 
+                       _ccsha3_384_di, _ccsha3_512_c_di, _ccsha3_512_di, _ccsha512_256_di, 
+                       _ccsha512_256_ltc_di, _ccsha512_di, _ccsha512_ltc_di, _ccsigma_clear, 
+                       _ccsigma_clear_key, _ccsigma_compute_mac, _ccsigma_derive_session_keys, 
+                       _ccsigma_export_key_share, _ccsigma_import_peer_key_share, 
+                       _ccsigma_import_peer_verification_key, _ccsigma_import_signing_key, 
+                       _ccsigma_init, _ccsigma_kex_init_ctx, _ccsigma_kex_resp_ctx, 
+                       _ccsigma_mfi_info, _ccsigma_open, _ccsigma_peer_role, _ccsigma_seal, 
+                       _ccsigma_set_signing_function, _ccsigma_sign, _ccsigma_verify, 
+                       _ccsiv_aad, _ccsiv_block_size, _ccsiv_ciphertext_size, _ccsiv_context_size, 
+                       _ccsiv_crypt, _ccsiv_hmac_aad, _ccsiv_hmac_block_size, _ccsiv_hmac_ciphertext_size, 
+                       _ccsiv_hmac_context_size, _ccsiv_hmac_crypt, _ccsiv_hmac_init, 
+                       _ccsiv_hmac_one_shot, _ccsiv_hmac_plaintext_size, _ccsiv_hmac_reset, 
+                       _ccsiv_hmac_set_nonce, _ccsiv_init, _ccsiv_one_shot, _ccsiv_plaintext_size, 
+                       _ccsiv_reset, _ccsiv_set_nonce, _ccspake_cp_256, _ccspake_cp_384, 
+                       _ccspake_cp_521, _ccspake_generate_L, _ccspake_kex_generate, 
+                       _ccspake_kex_process, _ccspake_mac_compute, _ccspake_mac_hkdf_cmac_aes128_sha256, 
+                       _ccspake_mac_hkdf_hmac_sha256, _ccspake_mac_hkdf_hmac_sha512, 
+                       _ccspake_mac_verify_and_get_session_key, _ccspake_prover_init, 
+                       _ccspake_sizeof_ctx, _ccspake_sizeof_point, _ccspake_sizeof_w, 
+                       _ccspake_verifier_init, _ccsrp_client_process_challenge, _ccsrp_client_start_authentication, 
+                       _ccsrp_client_verify_session, _ccsrp_generate_salt_and_verification, 
+                       _ccsrp_generate_verifier, _ccsrp_gp_rfc5054_1024, _ccsrp_gp_rfc5054_2048, 
+                       _ccsrp_gp_rfc5054_3072, _ccsrp_gp_rfc5054_4096, _ccsrp_gp_rfc5054_8192, 
+                       _ccsrp_server_compute_session, _ccsrp_server_generate_public_key, 
+                       _ccsrp_server_start_authentication, _ccsrp_server_verify_session, 
+                       _ccss_shamir_parameters_init, _ccss_shamir_parameters_maximum_secret_length, 
+                       _ccss_shamir_share_bag_add_share, _ccss_shamir_share_bag_init, 
+                       _ccss_shamir_share_bag_recover_secret, _ccss_shamir_share_export, 
+                       _ccss_shamir_share_generator_deserialize, _ccss_shamir_share_generator_generate_share, 
+                       _ccss_shamir_share_generator_init, _ccss_shamir_share_generator_init_with_secrets_less_than_prime, 
+                       _ccss_shamir_share_generator_serialize, _ccss_shamir_share_import, 
+                       _ccss_shamir_share_init, _ccss_shamir_share_sizeof_y, _ccss_sizeof_generator, 
+                       _ccss_sizeof_parameters, _ccss_sizeof_shamir_share_generator_serialization, 
+                       _ccss_sizeof_share, _ccss_sizeof_share_bag, _ccvrf_derive_public_key, 
+                       _ccvrf_factory_irtfdraft03, _ccvrf_factory_irtfdraft03_default, 
+                       _ccvrf_proof_to_hash, _ccvrf_prove, _ccvrf_sizeof_hash, _ccvrf_sizeof_proof, 
+                       _ccvrf_sizeof_public_key, _ccvrf_sizeof_secret_key, _ccvrf_verify, 
+                       _ccwrap_auth_decrypt, _ccwrap_auth_decrypt_withiv, _ccwrap_auth_encrypt, 
+                       _ccwrap_auth_encrypt_withiv, _ccwrap_unwrapped_size, _ccwrap_wrapped_size, 
+                       _ccxts_block_size, _ccxts_context_size, _ccxts_init, _ccxts_one_shot, 
+                       _ccxts_set_tweak, _ccxts_update, _ccz_add, _ccz_addi, _ccz_bit, 
+                       _ccz_bitlen, _ccz_cmp, _ccz_cmpi, _ccz_divmod, _ccz_expmod, 
+                       _ccz_free, _ccz_init, _ccz_is_negative, _ccz_is_one, _ccz_is_prime, 
+                       _ccz_is_zero, _ccz_lsl, _ccz_lsr, _ccz_mod, _ccz_mul, _ccz_muli, 
+                       _ccz_mulmod, _ccz_neg, _ccz_random_bits, _ccz_read_radix, 
+                       _ccz_read_uint, _ccz_set, _ccz_set_bit, _ccz_seti, _ccz_size, 
+                       _ccz_sub, _ccz_subi, _ccz_trailing_zeros, _ccz_write_int, 
+                       _ccz_write_int_size, _ccz_write_radix, _ccz_write_radix_size, 
+                       _ccz_write_uint, _ccz_write_uint_size, _ccz_zero, _cczp_add, 
+                       _cczp_inv, _cczp_mod, _cczp_mul, _cczp_sub, _csss_shamir_share_bag_can_recover_secret, 
+                       _fipspost_post, _fipspost_trace_vtable, _map_to_curve_sswu ]
+  - targets:         [ arm64-macos, arm64-maccatalyst, arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _ccaes_arm_cbc_decrypt_mode, _ccaes_arm_cbc_encrypt_mode, 
+                       _ccaes_arm_cfb_decrypt_mode, _ccaes_arm_cfb_encrypt_mode, 
+                       _ccaes_arm_ecb_decrypt_mode, _ccaes_arm_ecb_encrypt_mode, 
+                       _ccaes_arm_ofb_crypt_mode, _ccaes_arm_xts_decrypt_mode, _ccaes_arm_xts_encrypt_mode, 
+                       _ccsha1_vng_arm_di, _ccsha224_vng_arm_di, _ccsha256_vng_arm64neon_di, 
+                       _ccsha256_vng_arm_di, _ccsha384_vng_arm_di, _ccsha512_256_vng_arm_di, 
+                       _ccsha512_vng_arm_di ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           817339A1-D03E-3E54-9C47-ACACF69F6193
+  - target:          x86_64-maccatalyst
+    value:           817339A1-D03E-3E54-9C47-ACACF69F6193
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           40C9C98C-00D6-3E8E-9AD3-2ED6CF0D0CFE
+  - target:          arm64e-maccatalyst
+    value:           40C9C98C-00D6-3E8E-9AD3-2ED6CF0D0CFE
+install-name:    '/usr/lib/system/libdispatch.dylib'
+current-version: 1412
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ '$ld$hide$os10.12$_dispatch_assert_queue', '$ld$hide$os10.12$_dispatch_assert_queue_not', 
+                       '$ld$hide$os10.12$_dispatch_queue_create_with_target', __dispatch_begin_NSAutoReleasePool, 
+                       __dispatch_bug, __dispatch_data_destructor_free, __dispatch_data_destructor_munmap, 
+                       __dispatch_data_destructor_none, __dispatch_data_destructor_vm_deallocate, 
+                       __dispatch_data_empty, __dispatch_data_format_type_base32, 
+                       __dispatch_data_format_type_base32hex, __dispatch_data_format_type_base64, 
+                       __dispatch_data_format_type_none, __dispatch_data_format_type_utf16be, 
+                       __dispatch_data_format_type_utf16le, __dispatch_data_format_type_utf8, 
+                       __dispatch_data_format_type_utf_any, __dispatch_end_NSAutoReleasePool, 
+                       __dispatch_get_main_queue_handle_4CF, __dispatch_get_main_queue_port_4CF, 
+                       __dispatch_iocntl, __dispatch_is_fork_of_multithreaded_parent, 
+                       __dispatch_is_multithreaded, __dispatch_log, __dispatch_mach_hooks_install_default, 
+                       __dispatch_main_q, __dispatch_main_queue_callback_4CF, __dispatch_poll_for_events_4launchd, 
+                       __dispatch_prohibit_transition_to_multithreaded, __dispatch_pthread_root_queue_create_with_observer_hooks_4IOHID, 
+                       __dispatch_queue_attr_concurrent, __dispatch_queue_is_exclusively_owned_by_current_thread_4IOHID, 
+                       __dispatch_runloop_root_queue_create_4CF, __dispatch_runloop_root_queue_get_port_4CF, 
+                       __dispatch_runloop_root_queue_perform_4CF, __dispatch_runloop_root_queue_wakeup_4CF, 
+                       __dispatch_source_set_runloop_timer_4CF, __dispatch_source_type_data_add, 
+                       __dispatch_source_type_data_or, __dispatch_source_type_data_replace, 
+                       __dispatch_source_type_interval, __dispatch_source_type_mach_recv, 
+                       __dispatch_source_type_mach_send, __dispatch_source_type_memorypressure, 
+                       __dispatch_source_type_memorystatus, __dispatch_source_type_nw_channel, 
+                       __dispatch_source_type_proc, __dispatch_source_type_read, 
+                       __dispatch_source_type_signal, __dispatch_source_type_sock, 
+                       __dispatch_source_type_timer, __dispatch_source_type_vfs, 
+                       __dispatch_source_type_vm, __dispatch_source_type_vnode, __dispatch_source_type_write, 
+                       __dispatch_source_will_reenable_kevent_4NW, __dispatch_wait_for_enqueuer, 
+                       __dispatch_workloop_set_observer_hooks_4IOHID, __dispatch_workloop_should_yield_4NW, 
+                       __firehose_spi_version, __os_object_alloc, __os_object_alloc_realized, 
+                       __os_object_dealloc, __os_object_release, __os_object_release_internal, 
+                       __os_object_release_internal_n, __os_object_release_without_xref_dispose, 
+                       __os_object_retain, __os_object_retain_internal, __os_object_retain_internal_n, 
+                       __os_object_retain_with_resurrect, _dispatch_activate, _dispatch_after, 
+                       _dispatch_after_f, _dispatch_allocator_layout, _dispatch_apply, 
+                       _dispatch_apply_attr_destroy, _dispatch_apply_attr_init, _dispatch_apply_attr_query, 
+                       _dispatch_apply_attr_set_parallelism, _dispatch_apply_f, _dispatch_apply_with_attr, 
+                       _dispatch_apply_with_attr_f, _dispatch_assert_queue, '_dispatch_assert_queue$V2', 
+                       _dispatch_assert_queue_barrier, _dispatch_assert_queue_not, 
+                       '_dispatch_assert_queue_not$V2', _dispatch_async, _dispatch_async_and_wait, 
+                       _dispatch_async_and_wait_f, _dispatch_async_enforce_qos_class_f, 
+                       _dispatch_async_f, _dispatch_async_swift_job, _dispatch_atfork_child, 
+                       _dispatch_atfork_parent, _dispatch_atfork_prepare, _dispatch_barrier_async, 
+                       _dispatch_barrier_async_and_wait, _dispatch_barrier_async_and_wait_f, 
+                       _dispatch_barrier_async_f, _dispatch_barrier_sync, _dispatch_barrier_sync_f, 
+                       _dispatch_benchmark, _dispatch_benchmark_f, _dispatch_block_cancel, 
+                       _dispatch_block_create, _dispatch_block_create_with_qos_class, 
+                       _dispatch_block_create_with_voucher, _dispatch_block_create_with_voucher_and_qos_class, 
+                       _dispatch_block_notify, _dispatch_block_perform, _dispatch_block_testcancel, 
+                       _dispatch_block_wait, _dispatch_channel_async, _dispatch_channel_async_f, 
+                       _dispatch_channel_cancel, _dispatch_channel_create, _dispatch_channel_drain, 
+                       _dispatch_channel_drain_f, _dispatch_channel_enqueue, _dispatch_channel_foreach_work_item_peek, 
+                       _dispatch_channel_foreach_work_item_peek_f, _dispatch_channel_testcancel, 
+                       _dispatch_channel_wakeup, _dispatch_data_apply, _dispatch_data_apply_f, 
+                       _dispatch_data_copy_region, _dispatch_data_create, _dispatch_data_create_alloc, 
+                       _dispatch_data_create_concat, _dispatch_data_create_f, _dispatch_data_create_map, 
+                       _dispatch_data_create_subrange, _dispatch_data_create_with_transform, 
+                       _dispatch_data_get_flattened_bytes_4libxpc, _dispatch_data_get_size, 
+                       _dispatch_data_make_memory_entry, _dispatch_debug, _dispatch_debugv, 
+                       _dispatch_get_context, _dispatch_get_current_queue, _dispatch_get_global_queue, 
+                       _dispatch_get_specific, _dispatch_group_async, _dispatch_group_async_f, 
+                       _dispatch_group_create, _dispatch_group_enter, _dispatch_group_leave, 
+                       _dispatch_group_notify, _dispatch_group_notify_f, _dispatch_group_wait, 
+                       _dispatch_io_barrier, _dispatch_io_barrier_f, _dispatch_io_close, 
+                       _dispatch_io_create, _dispatch_io_create_f, _dispatch_io_create_with_io, 
+                       _dispatch_io_create_with_io_f, _dispatch_io_create_with_path, 
+                       _dispatch_io_create_with_path_f, _dispatch_io_get_descriptor, 
+                       _dispatch_io_read, _dispatch_io_read_f, _dispatch_io_set_high_water, 
+                       _dispatch_io_set_interval, _dispatch_io_set_low_water, _dispatch_io_write, 
+                       _dispatch_io_write_f, _dispatch_lock_override_end, _dispatch_lock_override_start_with_debounce, 
+                       _dispatch_mach_can_handoff_4libxpc, _dispatch_mach_cancel, 
+                       _dispatch_mach_connect, _dispatch_mach_create, _dispatch_mach_create_4libxpc, 
+                       _dispatch_mach_create_f, _dispatch_mach_get_checkin_port, 
+                       _dispatch_mach_handoff_reply, _dispatch_mach_handoff_reply_f, 
+                       _dispatch_mach_hooks_install_4libxpc, _dispatch_mach_mig_demux, 
+                       _dispatch_mach_mig_demux_get_context, _dispatch_mach_msg_create, 
+                       _dispatch_mach_msg_get_context, _dispatch_mach_msg_get_filter_policy_id, 
+                       _dispatch_mach_msg_get_msg, _dispatch_mach_notify_no_senders, 
+                       _dispatch_mach_receive_barrier, _dispatch_mach_receive_barrier_f, 
+                       _dispatch_mach_reconnect, _dispatch_mach_request_no_senders, 
+                       _dispatch_mach_send, _dispatch_mach_send_and_wait_for_reply, 
+                       _dispatch_mach_send_barrier, _dispatch_mach_send_barrier_f, 
+                       _dispatch_mach_send_with_result, _dispatch_mach_send_with_result_and_async_reply_4libxpc, 
+                       _dispatch_mach_send_with_result_and_wait_for_reply, _dispatch_mach_set_flags, 
+                       _dispatch_main, _dispatch_mig_server, _dispatch_once, _dispatch_once_f, 
+                       _dispatch_pthread_root_queue_copy_current, _dispatch_pthread_root_queue_create, 
+                       _dispatch_queue_attr_make_initially_inactive, _dispatch_queue_attr_make_with_autorelease_frequency, 
+                       _dispatch_queue_attr_make_with_overcommit, _dispatch_queue_attr_make_with_qos_class, 
+                       _dispatch_queue_create, _dispatch_queue_create_with_accounting_override_voucher, 
+                       _dispatch_queue_create_with_target, '_dispatch_queue_create_with_target$V2', 
+                       _dispatch_queue_get_label, _dispatch_queue_get_qos_class, 
+                       _dispatch_queue_get_specific, _dispatch_queue_offsets, _dispatch_queue_set_label_nocopy, 
+                       _dispatch_queue_set_specific, _dispatch_queue_set_width, _dispatch_read, 
+                       _dispatch_read_f, _dispatch_release, _dispatch_resume, _dispatch_retain, 
+                       _dispatch_semaphore_create, _dispatch_semaphore_signal, _dispatch_semaphore_wait, 
+                       _dispatch_set_context, _dispatch_set_finalizer_f, _dispatch_set_qos_class, 
+                       _dispatch_set_qos_class_fallback, _dispatch_set_qos_class_floor, 
+                       _dispatch_set_target_queue, _dispatch_source_cancel, _dispatch_source_cancel_and_wait, 
+                       _dispatch_source_create, _dispatch_source_get_data, _dispatch_source_get_extended_data, 
+                       _dispatch_source_get_handle, _dispatch_source_get_mask, _dispatch_source_merge_data, 
+                       _dispatch_source_set_cancel_handler, _dispatch_source_set_cancel_handler_f, 
+                       _dispatch_source_set_event_handler, _dispatch_source_set_event_handler_f, 
+                       _dispatch_source_set_mandatory_cancel_handler, _dispatch_source_set_mandatory_cancel_handler_f, 
+                       _dispatch_source_set_registration_handler, _dispatch_source_set_registration_handler_f, 
+                       _dispatch_source_set_timer, _dispatch_source_testcancel, _dispatch_suspend, 
+                       _dispatch_swift_job_should_yield, _dispatch_sync, _dispatch_sync_f, 
+                       _dispatch_thread_get_current_override_qos_floor, _dispatch_thread_override_self, 
+                       _dispatch_time, _dispatch_time_from_nsec, _dispatch_time_to_nsec, 
+                       _dispatch_time_to_nsecs, _dispatch_tsd_indexes, _dispatch_walltime, 
+                       _dispatch_workloop_copy_current, _dispatch_workloop_create, 
+                       _dispatch_workloop_create_inactive, _dispatch_workloop_is_current, 
+                       _dispatch_workloop_set_autorelease_frequency, _dispatch_workloop_set_cpupercent, 
+                       _dispatch_workloop_set_os_workgroup, _dispatch_workloop_set_qos_class, 
+                       _dispatch_workloop_set_qos_class_floor, _dispatch_workloop_set_scheduler_priority, 
+                       _dispatch_write, _dispatch_write_f, _libdispatch_init, _mach_voucher_persona_for_originator, 
+                       _mach_voucher_persona_self, _os_eventlink_activate, _os_eventlink_associate, 
+                       _os_eventlink_cancel, _os_eventlink_create, _os_eventlink_create_remote_with_eventlink, 
+                       _os_eventlink_create_with_port, _os_eventlink_disassociate, 
+                       _os_eventlink_extract_remote_port, _os_eventlink_signal, _os_eventlink_signal_and_wait, 
+                       _os_eventlink_signal_and_wait_until, _os_eventlink_wait, _os_eventlink_wait_until, 
+                       _os_release, _os_retain, _os_workgroup_attr_set_flags, _os_workgroup_attr_set_interval_type, 
+                       _os_workgroup_cancel, _os_workgroup_copy_port, _os_workgroup_create, 
+                       _os_workgroup_create_with_port, _os_workgroup_create_with_workgroup, 
+                       _os_workgroup_create_with_workload_id, _os_workgroup_create_with_workload_id_and_port, 
+                       _os_workgroup_create_with_workload_id_and_workgroup, _os_workgroup_get_working_arena, 
+                       _os_workgroup_interval_copy_current_4AudioToolbox, _os_workgroup_interval_create, 
+                       _os_workgroup_interval_create_with_workload_id, _os_workgroup_interval_data_set_flags, 
+                       _os_workgroup_interval_finish, _os_workgroup_interval_start, 
+                       _os_workgroup_interval_update, _os_workgroup_join, _os_workgroup_join_self, 
+                       _os_workgroup_leave, _os_workgroup_leave_self, _os_workgroup_max_parallel_threads, 
+                       _os_workgroup_parallel_create, _os_workgroup_set_working_arena, 
+                       _os_workgroup_testcancel, _voucher_activity_create_with_data, 
+                       _voucher_activity_create_with_location, _voucher_activity_flush, 
+                       _voucher_activity_get_logging_preferences, _voucher_activity_get_metadata_buffer, 
+                       _voucher_activity_id_allocate, _voucher_activity_initialize_4libtrace, 
+                       _voucher_activity_should_send_strings, _voucher_activity_trace, 
+                       _voucher_activity_trace_v, _voucher_activity_trace_v_2, _voucher_adopt, 
+                       _voucher_copy, _voucher_copy_with_persona_mach_voucher, _voucher_copy_without_importance, 
+                       _voucher_create_with_mach_msg, _voucher_decrement_importance_count4CF, 
+                       _voucher_get_activity_id, _voucher_get_activity_id_and_creator, 
+                       _voucher_get_current_persona, _voucher_get_current_persona_originator_info, 
+                       _voucher_get_current_persona_proximate_info, _voucher_kvoucher_debug, 
+                       _voucher_process_can_use_arbitrary_personas, _voucher_release, 
+                       _voucher_replace_default_voucher, _voucher_retain ]
+    objc-classes:    [ OS_dispatch_channel, OS_dispatch_data, OS_dispatch_disk, OS_dispatch_group, 
+                       OS_dispatch_io, OS_dispatch_mach, OS_dispatch_mach_msg, OS_dispatch_object, 
+                       OS_dispatch_operation, OS_dispatch_queue, OS_dispatch_queue_attr, 
+                       OS_dispatch_queue_concurrent, OS_dispatch_queue_global, OS_dispatch_queue_main, 
+                       OS_dispatch_queue_serial, OS_dispatch_semaphore, OS_dispatch_source, 
+                       OS_dispatch_workloop, OS_object, OS_os_eventlink, OS_os_workgroup, 
+                       OS_os_workgroup_interval, OS_os_workgroup_parallel, OS_voucher ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           6C8B449A-78F4-3127-BC23-910719DE96AB
+  - target:          x86_64-maccatalyst
+    value:           6C8B449A-78F4-3127-BC23-910719DE96AB
+  - target:          arm64-macos
+    value:           C52D0F3B-0BAE-376B-A851-943F95388DD7
+  - target:          arm64-maccatalyst
+    value:           C52D0F3B-0BAE-376B-A851-943F95388DD7
+  - target:          arm64e-macos
+    value:           668F3379-151D-3ED4-859C-8F56E7941CDE
+  - target:          arm64e-maccatalyst
+    value:           668F3379-151D-3ED4-859C-8F56E7941CDE
+install-name:    '/usr/lib/system/libdyld.dylib'
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _NSAddImage, _NSAddLibrary, _NSAddLibraryWithSearching, _NSAddressOfSymbol, 
+                       _NSCreateObjectFileImageFromFile, _NSCreateObjectFileImageFromMemory, 
+                       _NSDestroyObjectFileImage, _NSGetSectionDataInObjectFileImage, 
+                       _NSInstallLinkEditErrorHandlers, _NSIsSymbolDefinedInObjectFileImage, 
+                       _NSIsSymbolNameDefined, _NSIsSymbolNameDefinedInImage, _NSIsSymbolNameDefinedWithHint, 
+                       _NSLibraryNameForModule, _NSLinkEditError, _NSLinkModule, 
+                       _NSLookupAndBindSymbol, _NSLookupAndBindSymbolWithHint, _NSLookupSymbolInImage, 
+                       _NSLookupSymbolInModule, _NSModuleForSymbol, _NSNameOfModule, 
+                       _NSNameOfSymbol, _NSSymbolDefinitionCountInObjectFileImage, 
+                       _NSSymbolDefinitionNameInObjectFileImage, _NSSymbolReferenceCountInObjectFileImage, 
+                       _NSSymbolReferenceNameInObjectFileImage, _NSUnLinkModule, 
+                       _NSVersionOfLinkTimeLibrary, _NSVersionOfRunTimeLibrary, _NXArgc, 
+                       _NXArgv, __NSGetExecutablePath, ___progname, __dyld_all_twolevel_modules_prebound, 
+                       __dyld_atfork_parent, __dyld_atfork_prepare, __dyld_bind_fully_image_containing_address, 
+                       __dyld_dlopen_atfork_child, __dyld_dlopen_atfork_parent, __dyld_dlopen_atfork_prepare, 
+                       __dyld_find_foreign_type_protocol_conformance, __dyld_find_foreign_type_protocol_conformance_on_disk, 
+                       __dyld_find_protocol_conformance, __dyld_find_protocol_conformance_on_disk, 
+                       __dyld_find_unwind_sections, __dyld_for_each_objc_class, __dyld_for_each_objc_protocol, 
+                       __dyld_fork_child, __dyld_get_dlopen_image_header, __dyld_get_image_header, 
+                       __dyld_get_image_header_containing_address, __dyld_get_image_name, 
+                       __dyld_get_image_slide, __dyld_get_image_uuid, __dyld_get_image_vmaddr_slide, 
+                       __dyld_get_objc_selector, __dyld_get_prog_image_header, __dyld_get_shared_cache_range, 
+                       __dyld_get_shared_cache_uuid, __dyld_has_fix_for_radar, __dyld_has_preoptimized_swift_protocol_conformances, 
+                       __dyld_image_containing_address, __dyld_image_count, __dyld_images_for_addresses, 
+                       __dyld_initializer, __dyld_is_memory_immutable, __dyld_is_objc_constant, 
+                       __dyld_launch_mode, __dyld_launched_prebound, __dyld_lookup_and_bind, 
+                       __dyld_lookup_and_bind_fully, __dyld_lookup_and_bind_with_hint, 
+                       __dyld_missing_symbol_abort, __dyld_objc_class_count, __dyld_objc_notify_register, 
+                       __dyld_objc_register_callbacks, __dyld_objc_uses_large_shared_cache, 
+                       __dyld_present, __dyld_process_info_create, __dyld_process_info_for_each_aot_image, 
+                       __dyld_process_info_for_each_image, __dyld_process_info_for_each_segment, 
+                       __dyld_process_info_get_aot_cache, __dyld_process_info_get_cache, 
+                       __dyld_process_info_get_platform, __dyld_process_info_get_state, 
+                       __dyld_process_info_notify, __dyld_process_info_notify_main, 
+                       __dyld_process_info_notify_release, __dyld_process_info_notify_retain, 
+                       __dyld_process_info_release, __dyld_process_info_retain, __dyld_register_driverkit_main, 
+                       __dyld_register_for_bulk_image_loads, __dyld_register_for_image_loads, 
+                       __dyld_register_func_for_add_image, __dyld_register_func_for_remove_image, 
+                       __dyld_shared_cache_contains_path, __dyld_shared_cache_is_locally_built, 
+                       __dyld_shared_cache_optimized, __dyld_shared_cache_real_path, 
+                       __dyld_swift_optimizations_version, __dyld_visit_objc_classes, 
+                       __tlv_atexit, __tlv_bootstrap, __tlv_exit, _dladdr, _dlclose, 
+                       _dlerror, _dlopen, _dlopen_audited, _dlopen_from, _dlopen_preflight, 
+                       _dlsym, _dyldVersionNumber, _dyldVersionString, _dyld_dynamic_interpose, 
+                       _dyld_for_each_installed_shared_cache, _dyld_for_each_installed_shared_cache_with_system_path, 
+                       _dyld_get_active_platform, _dyld_get_base_platform, _dyld_get_image_versions, 
+                       _dyld_get_min_os_version, _dyld_get_program_min_os_version, 
+                       _dyld_get_program_sdk_version, _dyld_get_sdk_version, _dyld_has_inserted_or_interposing_libraries, 
+                       _dyld_image_content_for_section, _dyld_image_content_for_segment, 
+                       _dyld_image_copy_uuid, _dyld_image_for_each_section_info, 
+                       _dyld_image_for_each_segment_info, _dyld_image_get_file_path, 
+                       _dyld_image_get_installname, _dyld_image_header_containing_address, 
+                       _dyld_image_local_nlist_content_4Symbolication, _dyld_image_path_containing_address, 
+                       _dyld_is_simulator_platform, _dyld_minos_at_least, _dyld_need_closure, 
+                       _dyld_process_create_for_current_task, _dyld_process_create_for_task, 
+                       _dyld_process_dispose, _dyld_process_has_objc_patches, _dyld_process_is_restricted, 
+                       _dyld_process_register_for_event_notification, _dyld_process_register_for_image_notifications, 
+                       _dyld_process_snapshot_create_for_process, _dyld_process_snapshot_create_from_data, 
+                       _dyld_process_snapshot_dispose, _dyld_process_snapshot_for_each_image, 
+                       _dyld_process_snapshot_get_shared_cache, _dyld_process_unregister_for_notification, 
+                       _dyld_program_minos_at_least, _dyld_program_sdk_at_least, 
+                       _dyld_sdk_at_least, _dyld_shared_cache_copy_uuid, _dyld_shared_cache_file_path, 
+                       _dyld_shared_cache_find_iterate_text, _dyld_shared_cache_for_each_file, 
+                       _dyld_shared_cache_for_each_image, _dyld_shared_cache_for_file, 
+                       _dyld_shared_cache_get_base_address, _dyld_shared_cache_get_mapped_size, 
+                       _dyld_shared_cache_is_mapped_private, _dyld_shared_cache_iterate_text, 
+                       _dyld_shared_cache_pin_mapping, _dyld_shared_cache_some_image_overridden, 
+                       _dyld_shared_cache_unpin_mapping, _environ, _macho_arch_name_for_cpu_type, 
+                       _macho_arch_name_for_mach_header, _macho_best_slice, _macho_best_slice_in_fd, 
+                       _macho_cpu_type_for_arch_name, _macho_dylib_install_name, 
+                       _macho_for_each_slice, _macho_for_each_slice_in_fd, dyld_stub_binder ]
+  - targets:         [ x86_64-macos, arm64-macos, arm64e-macos ]
+    symbols:         [ _dyld_shared_cache_for_each_subcache4Rosetta, _dyld_shared_subcache_get_info4Rosetta ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           564464C5-4B61-34E4-A937-2BDB5399DFCB
+  - target:          x86_64-maccatalyst
+    value:           564464C5-4B61-34E4-A937-2BDB5399DFCB
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           50343076-2AC5-36B5-8B00-C7182678C6AC
+  - target:          arm64e-maccatalyst
+    value:           50343076-2AC5-36B5-8B00-C7182678C6AC
+install-name:    '/usr/lib/system/libkeymgr.dylib'
+current-version: 31
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ ___keymgr_dwarf2_register_sections, ___keymgr_initializer, 
+                       __keymgr_get_and_lock_processwide_ptr, __keymgr_get_and_lock_processwide_ptr_2, 
+                       __keymgr_get_lock_count_processwide_ptr, __keymgr_get_lockmode_processwide_ptr, 
+                       __keymgr_set_and_unlock_processwide_ptr, __keymgr_set_lockmode_processwide_ptr, 
+                       __keymgr_unlock_processwide_ptr, _keymgrVersionNumber, _keymgrVersionString ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64e-macos ]
+uuids:
+  - target:          x86_64-macos
+    value:           4573BDD5-4817-3D26-B6A7-38AAE653FCBC
+  - target:          x86_64-maccatalyst
+    value:           4573BDD5-4817-3D26-B6A7-38AAE653FCBC
+  - target:          arm64-macos
+    value:           B695C46E-649C-3047-AF7D-ED475E37DE56
+  - target:          arm64-maccatalyst
+    value:           B695C46E-649C-3047-AF7D-ED475E37DE56
+  - target:          arm64e-macos
+    value:           B4352C72-0618-3135-B375-BFF70DB8C3F2
+  - target:          arm64e-maccatalyst
+    value:           B4352C72-0618-3135-B375-BFF70DB8C3F2
+install-name:    '/usr/lib/system/libmacho.dylib'
+current-version: 1001.2
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64e-macos ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64e-macos ]
+    symbols:         [ _NXCombineCpuSubtypes, _NXFindBestFatArch, _NXFindBestFatArch_64, 
+                       _NXFreeArchInfo, _NXGetAllArchInfos, _NXGetArchInfoFromCpuType, 
+                       _NXGetArchInfoFromName, _NXGetLocalArchInfo, _get_edata, _get_end, 
+                       _get_etext, _getsectbyname, _getsectbynamefromheader, _getsectbynamefromheader_64, 
+                       _getsectbynamefromheaderwithswap, _getsectbynamefromheaderwithswap_64, 
+                       _getsectdata, _getsectdatafromFramework, _getsectdatafromheader, 
+                       _getsectdatafromheader_64, _getsectiondata, _getsegbyname, 
+                       _getsegmentdata, _slot_name, _swap_build_tool_version, _swap_build_version_command, 
+                       _swap_dyld_info_command, _swap_dylib_command, _swap_dylib_module, 
+                       _swap_dylib_module_64, _swap_dylib_reference, _swap_dylib_table_of_contents, 
+                       _swap_dylinker_command, _swap_dysymtab_command, _swap_encryption_command, 
+                       _swap_encryption_command_64, _swap_entry_point_command, _swap_fat_arch, 
+                       _swap_fat_arch_64, _swap_fat_header, _swap_fileset_entry_command, 
+                       _swap_fvmfile_command, _swap_fvmlib_command, _swap_hppa_fp_thread_state, 
+                       _swap_hppa_frame_thread_state, _swap_hppa_integer_thread_state, 
+                       _swap_i386_exception_state, _swap_i386_float_state, _swap_i386_thread_state, 
+                       _swap_i860_thread_state_regs, _swap_ident_command, _swap_indirect_symbols, 
+                       _swap_linkedit_data_command, _swap_linker_option_command, 
+                       _swap_load_command, _swap_m68k_thread_state_68882, _swap_m68k_thread_state_regs, 
+                       _swap_m68k_thread_state_user_reg, _swap_m88110_thread_state_impl_t, 
+                       _swap_m88k_thread_state_grf_t, _swap_m88k_thread_state_user_t, 
+                       _swap_m88k_thread_state_xrf_t, _swap_mach_header, _swap_mach_header_64, 
+                       _swap_nlist, _swap_nlist_64, _swap_note_command, _swap_ppc_exception_state_t, 
+                       _swap_ppc_float_state_t, _swap_ppc_thread_state_t, _swap_prebind_cksum_command, 
+                       _swap_prebound_dylib_command, _swap_ranlib, _swap_ranlib_64, 
+                       _swap_relocation_info, _swap_routines_command, _swap_routines_command_64, 
+                       _swap_rpath_command, _swap_section, _swap_section_64, _swap_segment_command, 
+                       _swap_segment_command_64, _swap_source_version_command, _swap_sparc_thread_state_fpu, 
+                       _swap_sparc_thread_state_regs, _swap_sub_client_command, _swap_sub_framework_command, 
+                       _swap_sub_library_command, _swap_sub_umbrella_command, _swap_symseg_command, 
+                       _swap_symtab_command, _swap_thread_command, _swap_twolevel_hint, 
+                       _swap_twolevel_hints_command, _swap_uuid_command, _swap_version_min_command, 
+                       _swap_x86_debug_state, _swap_x86_debug_state32, _swap_x86_debug_state64, 
+                       _swap_x86_exception_state, _swap_x86_exception_state64, _swap_x86_float_state, 
+                       _swap_x86_float_state64, _swap_x86_state_hdr, _swap_x86_thread_state, 
+                       _swap_x86_thread_state64 ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           928130DD-5A8D-3546-BA85-242E4051CEF2
+  - target:          x86_64-maccatalyst
+    value:           928130DD-5A8D-3546-BA85-242E4051CEF2
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           2009EBC7-36D7-32AA-AD6A-25CE4128B3C0
+  - target:          arm64e-maccatalyst
+    value:           2009EBC7-36D7-32AA-AD6A-25CE4128B3C0
+install-name:    '/usr/lib/system/libquarantine.dylib'
+current-version: 146.40.2
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ ___esp_check, ___esp_check_ns, ___esp_enabled, ___esp_notify, 
+                       ___esp_notify_ns, __qtn_error, __qtn_file_alloc, __qtn_file_apply_to_fd, 
+                       __qtn_file_apply_to_mount_point, __qtn_file_apply_to_path, 
+                       __qtn_file_clone, __qtn_file_free, __qtn_file_get_flags, __qtn_file_get_identifier, 
+                       __qtn_file_get_metadata, __qtn_file_get_metadata_size, __qtn_file_get_timestamp, 
+                       __qtn_file_init, __qtn_file_init_with_data, __qtn_file_init_with_fd, 
+                       __qtn_file_init_with_mount_point, __qtn_file_init_with_path, 
+                       __qtn_file_set_flags, __qtn_file_set_identifier, __qtn_file_set_metadata, 
+                       __qtn_file_set_timestamp, __qtn_file_to_data, __qtn_label_name, 
+                       __qtn_proc_alloc, __qtn_proc_apply_to_pid, __qtn_proc_apply_to_self, 
+                       __qtn_proc_clone, __qtn_proc_free, __qtn_proc_get_flags, __qtn_proc_get_identifier, 
+                       __qtn_proc_get_metadata, __qtn_proc_get_metadata_size, __qtn_proc_get_path_exclusion_pattern, 
+                       __qtn_proc_get_tracking_data, __qtn_proc_get_tracking_size, 
+                       __qtn_proc_init, __qtn_proc_init_with_data, __qtn_proc_init_with_self, 
+                       __qtn_proc_set_flags, __qtn_proc_set_identifier, __qtn_proc_set_metadata, 
+                       __qtn_proc_set_path_exclusion_pattern, __qtn_proc_set_tracking_data, 
+                       __qtn_proc_to_data, __qtn_xattr_name, _qtn_proc_init_with_pid, 
+                       _responsibility_get_attribution_for_audittoken, _responsibility_get_pid_responsible_for_pid, 
+                       _responsibility_get_responsible_audit_token_for_audit_token, 
+                       _responsibility_get_responsible_for_pid, _responsibility_get_uniqueid_responsible_for_pid, 
+                       _responsibility_identity_get_binary_entitlement_data, _responsibility_identity_get_binary_is_platform, 
+                       _responsibility_identity_get_binary_offset, _responsibility_identity_get_binary_path, 
+                       _responsibility_identity_get_binary_signing_id, _responsibility_identity_get_binary_team_id, 
+                       _responsibility_identity_get_csflags, _responsibility_identity_get_hosted_path, 
+                       _responsibility_identity_get_hosted_team_id, _responsibility_identity_get_persistent_identifier, 
+                       _responsibility_identity_get_platform, _responsibility_identity_get_sdk, 
+                       _responsibility_identity_get_user_uuid, _responsibility_identity_release, 
+                       _responsibility_init, _responsibility_set_audittoken_responsible_for_caller, 
+                       _responsibility_set_audittoken_responsible_for_self, _responsibility_set_caller_responsible_for_self, 
+                       _responsibility_set_hosted_path, _responsibility_set_hosted_team_id, 
+                       _responsibility_set_pid_responsible_for_pid, _responsibility_spawnattrs_getdisclaim, 
+                       _responsibility_spawnattrs_setdisclaim ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           E922FC3F-83F1-3C07-AD9A-13ABE2883681
+  - target:          x86_64-maccatalyst
+    value:           E922FC3F-83F1-3C07-AD9A-13ABE2883681
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           51CF7D0E-014B-3E65-BDF3-A2DF337113BA
+  - target:          arm64e-maccatalyst
+    value:           51CF7D0E-014B-3E65-BDF3-A2DF337113BA
+install-name:    '/usr/lib/system/libremovefile.dylib'
+current-version: 63
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ ___removefile_init_random, ___removefile_random_char, ___removefile_randomize_buffer, 
+                       ___removefile_rename_unlink, ___removefile_sunlink, ___removefile_tree_walker, 
+                       _removefile, _removefile_cancel, _removefile_state_alloc, 
+                       _removefile_state_free, _removefile_state_get, _removefile_state_set, 
+                       _removefileat ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           136EA7B6-9D44-3363-8949-AF5D21C6D116
+  - target:          x86_64-maccatalyst
+    value:           136EA7B6-9D44-3363-8949-AF5D21C6D116
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           60ADB251-3204-34C0-B826-260AEF261E02
+  - target:          arm64e-maccatalyst
+    value:           60ADB251-3204-34C0-B826-260AEF261E02
+install-name:    '/usr/lib/system/libsystem_asl.dylib'
+current-version: 395
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _ASL_LEVEL_TO_STRING, __asl_evaluate_send, __asl_fork_child, 
+                       __asl_lib_log, __asl_log_args_to_xpc, __asl_msg_dump, __asl_mt_shim_fork_child, 
+                       __asl_mt_shim_send_message, __asl_server_cancel_direct_watch, 
+                       __asl_server_control_query, __asl_server_create_aux_link, 
+                       __asl_server_match, __asl_server_message, __asl_server_query_2, 
+                       __asl_server_register_direct_watch, _asl_add_log_file, _asl_add_output, 
+                       _asl_add_output_file, _asl_append, _asl_base_msg, _asl_client_add_output_file, 
+                       _asl_client_get_control, _asl_client_kvdict, _asl_client_match, 
+                       _asl_client_open, _asl_client_open_from_file, _asl_client_release, 
+                       _asl_client_remove_output_file, _asl_client_retain, _asl_client_search, 
+                       _asl_client_send, _asl_client_set_control, _asl_client_set_filter, 
+                       _asl_client_set_output_file_filter, _asl_close, _asl_close_auxiliary_file, 
+                       _asl_core_check_access, _asl_core_decode_buffer, _asl_core_encode_buffer, 
+                       _asl_core_error, _asl_core_get_service_port, _asl_core_htonq, 
+                       _asl_core_level_to_string, _asl_core_new_msg_id, _asl_core_ntohq, 
+                       _asl_core_parse_time, _asl_core_str_match, _asl_core_str_match_c_time, 
+                       _asl_core_str_match_char, _asl_core_str_to_size, _asl_core_str_to_time, 
+                       _asl_core_str_to_uint32, _asl_core_string_hash, _asl_core_time_to_str, 
+                       _asl_count, _asl_create_auxiliary_file, _asl_fetch_key_val_op, 
+                       _asl_file_close, _asl_file_compact, _asl_file_ctime, _asl_file_fetch, 
+                       _asl_file_fetch_next, _asl_file_fetch_previous, _asl_file_filter, 
+                       _asl_file_filter_level, _asl_file_list_add, _asl_file_list_close, 
+                       _asl_file_list_match, _asl_file_list_match_end, _asl_file_list_match_next, 
+                       _asl_file_list_match_start, _asl_file_match, _asl_file_open_read, 
+                       _asl_file_open_write, _asl_file_read_set_position, _asl_file_release, 
+                       _asl_file_retain, _asl_file_save, _asl_file_size, _asl_filesystem_path, 
+                       _asl_format, _asl_format_message, _asl_free, _asl_get, _asl_get_filter, 
+                       _asl_get_index, _asl_get_local_control, _asl_get_type, _asl_get_value_for_key, 
+                       _asl_key, _asl_legacy1_close, _asl_legacy1_fetch, _asl_legacy1_match, 
+                       _asl_legacy1_open, _asl_list_from_string, _asl_log, _asl_log_auxiliary_location, 
+                       _asl_log_descriptor, _asl_log_message, _asl_match, _asl_msg_cmp, 
+                       _asl_msg_cmp_list, _asl_msg_copy, _asl_msg_count, _asl_msg_fetch, 
+                       _asl_msg_from_string, _asl_msg_get_val_for_key, _asl_msg_key, 
+                       _asl_msg_list_append, _asl_msg_list_count, _asl_msg_list_from_string, 
+                       _asl_msg_list_get_index, _asl_msg_list_insert, _asl_msg_list_match, 
+                       _asl_msg_list_new, _asl_msg_list_new_count, _asl_msg_list_next, 
+                       _asl_msg_list_prepend, _asl_msg_list_prev, _asl_msg_list_release, 
+                       _asl_msg_list_remove_index, _asl_msg_list_reset_iteration, 
+                       _asl_msg_list_retain, _asl_msg_list_search, _asl_msg_list_to_asl_string, 
+                       _asl_msg_list_to_string, _asl_msg_lookup, _asl_msg_merge, 
+                       _asl_msg_new, _asl_msg_release, _asl_msg_retain, _asl_msg_set_key_val, 
+                       _asl_msg_set_key_val_op, _asl_msg_to_string, _asl_msg_type, 
+                       _asl_msg_unset, _asl_msg_unset_index, _asl_new, _asl_next, 
+                       _asl_object_append, _asl_object_count, _asl_object_get_key_val_op_at_index, 
+                       _asl_object_get_object_at_index, _asl_object_get_val_op_for_key, 
+                       _asl_object_match, _asl_object_next, _asl_object_prepend, 
+                       _asl_object_prev, _asl_object_remove_object_at_index, _asl_object_search, 
+                       _asl_object_set_iteration_index, _asl_object_set_key_val_op, 
+                       _asl_object_unset_key, _asl_open, _asl_open_from_file, _asl_open_path, 
+                       _asl_parse_time, _asl_prepend, _asl_prev, _asl_release, _asl_remote_notify_name, 
+                       _asl_remove_log_file, _asl_remove_output, _asl_remove_output_file, 
+                       _asl_reset_iteration, _asl_retain, _asl_search, _asl_send, 
+                       _asl_set, _asl_set_filter, _asl_set_key_val_op, _asl_set_local_control, 
+                       _asl_set_output_file_filter, _asl_set_query, _asl_store_close, 
+                       _asl_store_location, _asl_store_match, _asl_store_match_next, 
+                       _asl_store_match_start, _asl_store_match_timeout, _asl_store_max_file_size, 
+                       _asl_store_open_aux, _asl_store_open_read, _asl_store_open_write, 
+                       _asl_store_release, _asl_store_retain, _asl_store_save, _asl_store_set_flags, 
+                       _asl_store_statistics, _asl_store_sweep_file_cache, _asl_string_allocated_size, 
+                       _asl_string_append, _asl_string_append_asl_key, _asl_string_append_asl_msg, 
+                       _asl_string_append_char_no_encoding, _asl_string_append_no_encoding, 
+                       _asl_string_append_no_encoding_len, _asl_string_append_op, 
+                       _asl_string_append_xml_tag, _asl_string_bytes, _asl_string_length, 
+                       _asl_string_new, _asl_string_release, _asl_string_release_return_bytes, 
+                       _asl_string_retain, _asl_syslog_faciliy_name_to_num, _asl_syslog_faciliy_num_to_name, 
+                       _asl_trigger_aslmanager, _asl_unset, _asl_unset_key, _asl_vlog, 
+                       _aslresponse_free, _aslresponse_next, _closelog, _openlog, 
+                       _setlogmask, _syslog, '_syslog$DARWIN_EXTSN', _vsyslog ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           8AE2D1DF-B8E1-3564-810B-65C611BA237B
+  - target:          x86_64-maccatalyst
+    value:           8AE2D1DF-B8E1-3564-810B-65C611BA237B
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           2E8EE0E2-160C-3418-AFC4-3FD86B4E7A6E
+  - target:          arm64e-maccatalyst
+    value:           2E8EE0E2-160C-3418-AFC4-3FD86B4E7A6E
+install-name:    '/usr/lib/system/libsystem_blocks.dylib'
+current-version: 84
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _Block_size, __Block_copy, __Block_extended_layout, __Block_has_signature, 
+                       __Block_isDeallocating, __Block_layout, __Block_object_assign, 
+                       __Block_object_dispose, __Block_release, __Block_signature, 
+                       __Block_tryRetain, __Block_use_RR2, __Block_use_stret, __NSConcreteAutoBlock, 
+                       __NSConcreteFinalizingBlock, __NSConcreteGlobalBlock, __NSConcreteMallocBlock, 
+                       __NSConcreteStackBlock, __NSConcreteWeakBlockVariable ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           5EFAF10B-2EC1-32ED-B077-80125E552C8D
+  - target:          x86_64-maccatalyst
+    value:           5EFAF10B-2EC1-32ED-B077-80125E552C8D
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           A3869999-0792-3E09-B3FB-5E87AE4639BE
+  - target:          arm64e-maccatalyst
+    value:           A3869999-0792-3E09-B3FB-5E87AE4639BE
+install-name:    '/usr/lib/system/libsystem_c.dylib'
+current-version: 1534.40.2
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
+    symbols:         [ '___opendir2$INODE64', ___strtopx, '__readdir_unlocked$INODE64', 
+                       '__seekdir$INODE64', '_alphasort$INODE64', '_daemon$1050', 
+                       '_fdopendir$INODE64', _fstatx64_np, '_fstatx_np$INODE64', 
+                       '_fts_children$INODE64', '_fts_close$INODE64', '_fts_open$INODE64', 
+                       '_fts_open_b$INODE64', '_fts_read$INODE64', '_fts_set$INODE64', 
+                       '_ftw$INODE64', '_getmntinfo$INODE64', _getmntinfo64, '_getmntinfo_r_np$INODE64', 
+                       '_glob$INODE64', '_glob_b$INODE64', _lstatx64_np, '_lstatx_np$INODE64', 
+                       '_nftw$INODE64', '_opendir$INODE64', '_readdir$INODE64', '_readdir_r$INODE64', 
+                       '_rewinddir$INODE64', '_scandir$INODE64', '_scandir_b$INODE64', 
+                       '_seekdir$INODE64', _statx64_np, '_statx_np$INODE64', '_telldir$INODE64', 
+                       mcount ]
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ '$ld$weak$os10.11$_basename_r', '$ld$weak$os10.11$_clock_getres', 
+                       '$ld$weak$os10.11$_clock_gettime', '$ld$weak$os10.11$_clock_settime', 
+                       '$ld$weak$os10.11$_dirname_r', '$ld$weak$os10.11$_getentropy', 
+                       '$ld$weak$os10.11$_mkostemp', '$ld$weak$os10.11$_mkostemps', 
+                       '$ld$weak$os10.11$_timingsafe_bcmp', '$ld$weak$os10.12$_utimensat', 
+                       __CurrentRuneLocale, __DefaultRuneLocale, __Exit, __NSGetArgc, 
+                       __NSGetArgv, __NSGetEnviron, __NSGetMachExecuteHeader, __NSGetProgname, 
+                       __PathLocale, __Read_RuneMagi, ___Balloc_D2A, ___Bfree_D2A, 
+                       ___ULtod_D2A, ____mb_cur_max, ____mb_cur_max_l, ____runetype, 
+                       ____runetype_l, ____tolower, ____tolower_l, ____toupper, ____toupper_l, 
+                       ___add_ovflpage, ___addel, ___any_on_D2A, ___assert_rtn, ___b2d_D2A, 
+                       ___big_delete, ___big_insert, ___big_keydata, ___big_return, 
+                       ___big_split, ___bigtens_D2A, ___bt_close, ___bt_cmp, ___bt_defcmp, 
+                       ___bt_defpfx, ___bt_delete, ___bt_dleaf, ___bt_fd, ___bt_free, 
+                       ___bt_get, ___bt_new, ___bt_open, ___bt_pgin, ___bt_pgout, 
+                       ___bt_put, ___bt_ret, ___bt_search, ___bt_seq, ___bt_setcur, 
+                       ___bt_split, ___bt_sync, ___buf_free, ___call_hash, ___cleanup, 
+                       ___cmp_D2A, ___collate_equiv_match, ___collate_load_error, 
+                       ___collate_lookup, ___collate_lookup_l, ___copybits_D2A, ___cxa_atexit, 
+                       ___cxa_finalize, ___cxa_finalize_ranges, ___cxa_thread_atexit, 
+                       ___d2b_D2A, ___dbpanic, ___decrement_D2A, ___default_hash, 
+                       ___default_utx, ___delpair, ___diff_D2A, ___dtoa, ___expand_table, 
+                       ___fflush, ___fgetwc, ___find_bigpair, ___find_last_page, 
+                       ___fix_locale_grouping_str, ___fread, ___free_ovflpage, ___freedtoa, 
+                       ___gdtoa, ___gdtoa_locks, ___get_buf, ___get_page, ___gethex_D2A, 
+                       ___getonlyClocaleconv, ___hash_open, ___hdtoa, ___hexdig_D2A, 
+                       ___hexdig_init_D2A, ___hexnan_D2A, ___hi0bits_D2A, ___hldtoa, 
+                       ___i2b_D2A, ___ibitmap, ___increment_D2A, ___isctype, ___istype, 
+                       ___istype_l, ___ldtoa, ___libc_init, ___lo0bits_D2A, ___log2, 
+                       ___lshift_D2A, ___maskrune, ___maskrune_l, ___match_D2A, ___mb_cur_max, 
+                       ___mb_sb_limit, ___memccpy_chk, ___memcpy_chk, ___memmove_chk, 
+                       ___memset_chk, ___mult_D2A, ___multadd_D2A, ___nrv_alloc_D2A, 
+                       ___opendir2, ___ovfl_delete, ___ovfl_get, ___ovfl_put, ___pow5mult_D2A, 
+                       ___put_page, ___quorem_D2A, ___ratio_D2A, ___rec_close, ___rec_delete, 
+                       ___rec_dleaf, ___rec_fd, ___rec_fmap, ___rec_fpipe, ___rec_get, 
+                       ___rec_iput, ___rec_open, ___rec_put, ___rec_ret, ___rec_search, 
+                       ___rec_seq, ___rec_sync, ___rec_vmap, ___rec_vpipe, ___reclaim_buf, 
+                       ___rshift_D2A, ___rv_alloc_D2A, ___s2b_D2A, ___sF, ___sclose, 
+                       ___sdidinit, ___set_ones_D2A, ___setonlyClocaleconv, ___sflags, 
+                       ___sflush, ___sfp, ___sfvwrite, ___sglue, ___sinit, ___slbexpand, 
+                       ___smakebuf, ___snprintf_chk, ___snprintf_object_size_chk, 
+                       ___split_page, ___sprintf_chk, ___sprintf_object_size_chk, 
+                       ___sread, ___srefill, ___srget, ___sseek, ___stack_chk_fail, 
+                       ___stack_chk_guard, ___stderrp, ___stdinp, ___stdoutp, ___stpcpy_chk, 
+                       ___stpncpy_chk, ___strcat_chk, ___strcp_D2A, ___strcpy_chk, 
+                       ___strlcat_chk, ___strlcpy_chk, ___strncat_chk, ___strncpy_chk, 
+                       ___strtodg, ___strtopdd, ___sum_D2A, ___svfscanf, ___swbuf, 
+                       ___swhatbuf, ___swrite, ___swsetup, ___tens_D2A, ___tinytens_D2A, 
+                       ___tolower, ___tolower_l, ___toupper, ___toupper_l, ___trailz_D2A, 
+                       ___ulp_D2A, ___ungetc, ___ungetwc, ___vsnprintf_chk, ___vsprintf_chk, 
+                       ___wcwidth, ___wcwidth_l, __allocenvstate, __atexit_receipt, 
+                       __c_locale, __cleanup, __closeutx, __copyenv, __cthread_init_routine, 
+                       __deallocenvstate, __endutxent, __flockfile_debug_stub, __fseeko, 
+                       __ftello, __fwalk, __getenvp, __getutxent, __getutxid, __getutxline, 
+                       __inet_aton_check, __init_clock_port, __int_to_time, __libc_fork_child, 
+                       __libc_initializer, __long_to_time, __mkpath_np, __mktemp, 
+                       __openutx, __os_assert_log, __os_assert_log_ctx, __os_assumes_log, 
+                       __os_assumes_log_ctx, __os_avoid_tail_call, __os_crash, __os_crash_callback, 
+                       __os_crash_fmt, __os_crash_msg, __os_debug_log, __os_debug_log_error_offset, 
+                       __os_debug_log_error_str, __putenvp, __pututxline, __rand48_add, 
+                       __rand48_mult, __rand48_seed, __readdir_unlocked, __reclaim_telldir, 
+                       __seekdir, __setenvp, __setutxent, __sigaction_nobind, __sigintr, 
+                       __signal_nobind, __sigvec_nobind, __sread, __sseek, __subsystem_init, 
+                       __swrite, __time32_to_time, __time64_to_time, __time_to_int, 
+                       __time_to_long, __time_to_time32, __time_to_time64, __unsetenvp, 
+                       __utmpxname, _a64l, _abort, _abort_report_np, _abs, _acl_add_flag_np, 
+                       _acl_add_perm, _acl_calc_mask, _acl_clear_flags_np, _acl_clear_perms, 
+                       _acl_copy_entry, _acl_copy_ext, _acl_copy_ext_native, _acl_copy_int, 
+                       _acl_copy_int_native, _acl_create_entry, _acl_create_entry_np, 
+                       _acl_delete_def_file, _acl_delete_entry, _acl_delete_fd_np, 
+                       _acl_delete_file_np, _acl_delete_flag_np, _acl_delete_link_np, 
+                       _acl_delete_perm, _acl_dup, _acl_free, _acl_from_text, _acl_get_entry, 
+                       _acl_get_fd, _acl_get_fd_np, _acl_get_file, _acl_get_flag_np, 
+                       _acl_get_flagset_np, _acl_get_link_np, _acl_get_perm_np, _acl_get_permset, 
+                       _acl_get_permset_mask_np, _acl_get_qualifier, _acl_get_tag_type, 
+                       _acl_init, _acl_maximal_permset_mask_np, _acl_set_fd, _acl_set_fd_np, 
+                       _acl_set_file, _acl_set_flagset_np, _acl_set_link_np, _acl_set_permset, 
+                       _acl_set_permset_mask_np, _acl_set_qualifier, _acl_set_tag_type, 
+                       _acl_size, _acl_to_text, _acl_valid, _acl_valid_fd_np, _acl_valid_file_np, 
+                       _acl_valid_link, _addr2ascii, _alarm, _alphasort, _arc4random, 
+                       _arc4random_addrandom, _arc4random_buf, _arc4random_stir, 
+                       _arc4random_uniform, _ascii2addr, _asctime, _asctime_r, _asprintf, 
+                       _asprintf_l, _asxprintf, _asxprintf_exec, _atexit, _atexit_b, 
+                       _atof, _atof_l, _atoi, _atoi_l, _atol, _atol_l, _atoll, _atoll_l, 
+                       _backtrace, _backtrace_async, _backtrace_from_fp, _backtrace_image_offsets, 
+                       _backtrace_symbols, _backtrace_symbols_fd, _basename, _basename_r, 
+                       _bcopy, _brk, _bsd_signal, _bsearch, _bsearch_b, _btowc, _btowc_l, 
+                       _catclose, _catgets, _catopen, _cfgetispeed, _cfgetospeed, 
+                       _cfmakeraw, _cfsetispeed, _cfsetospeed, _cfsetspeed, _cgetcap, 
+                       _cgetclose, _cgetent, _cgetfirst, _cgetmatch, _cgetnext, _cgetnum, 
+                       _cgetset, _cgetstr, _cgetustr, _chmodx_np, _clearerr, _clearerr_unlocked, 
+                       _clock, _clock_getres, _clock_gettime, _clock_gettime_nsec_np, 
+                       _clock_port, _clock_sem, _clock_settime, _closedir, _compat_mode, 
+                       _confstr, _copy_printf_domain, _creat, '_creat$NOCANCEL', 
+                       _crypt, _ctermid, _ctermid_r, _ctime, _ctime_r, _daemon, _daylight, 
+                       _dbm_clearerr, _dbm_close, _dbm_delete, _dbm_dirfno, _dbm_error, 
+                       _dbm_fetch, _dbm_firstkey, _dbm_nextkey, _dbm_open, _dbm_store, 
+                       _dbopen, _devname, _devname_r, _difftime, _digittoint, _digittoint_l, 
+                       _dirfd, _dirname, _dirname_r, _div, _dprintf, _dprintf_l, 
+                       _drand48, _duplocale, _dxprintf, _dxprintf_exec, _ecvt, _encrypt, 
+                       _endttyent, _endusershell, _endutxent, _endutxent_wtmp, _environ_lock_np, 
+                       _environ_unlock_np, _erand48, _err, _err_set_exit, _err_set_exit_b, 
+                       _err_set_file, _errc, _errx, _execl, _execle, _execlp, _execv, 
+                       _execvP, _execvp, _exit, _f_prealloc, _fchmodx_np, _fclose, 
+                       _fcvt, _fdopen, '_fdopen$DARWIN_EXTSN', _fdopendir, _feof, 
+                       _feof_unlocked, _ferror, _ferror_unlocked, _fflagstostr, _fflush, 
+                       _fgetc, _fgetln, _fgetpos, _fgetrune, _fgets, _fgetwc, _fgetwc_l, 
+                       _fgetwln, _fgetwln_l, _fgetws, _fgetws_l, _fileno, _fileno_unlocked, 
+                       _filesec_dup, _filesec_free, _filesec_get_property, _filesec_init, 
+                       _filesec_query_property, _filesec_set_property, _filesec_unset_property, 
+                       _flockfile, _fmemopen, _fmtcheck, _fmtmsg, _fnmatch, _fopen, 
+                       '_fopen$DARWIN_EXTSN', _fork, _forkpty, _fparseln, _fprintf, 
+                       _fprintf_l, _fpurge, _fputc, _fputrune, _fputs, _fputwc, _fputwc_l, 
+                       _fputws, _fputws_l, _fread, _free_printf_comp, _free_printf_domain, 
+                       _freelocale, _freopen, _fscanf, _fscanf_l, _fseek, _fseeko, 
+                       _fsetpos, _fstatvfs, _fstatx_np, _fsync_volume_np, _ftell, 
+                       _ftello, _ftime, _ftok, _ftrylockfile, _fts_children, _fts_close, 
+                       _fts_open, _fts_open_b, _fts_read, _fts_set, _ftw, _fungetrune, 
+                       _funlockfile, _funopen, _fwide, _fwprintf, _fwprintf_l, _fwrite, 
+                       _fwscanf, _fwscanf_l, _fxprintf, _fxprintf_exec, _gcvt, _getbsize, 
+                       _getc, _getc_unlocked, _getchar, _getchar_unlocked, _getcwd, 
+                       _getdate, _getdate_err, _getdelim, _getdiskbyname, _getenv, 
+                       '_getgroups$DARWIN_EXTSN', _gethostid, _gethostname, _getipv4sourcefilter, 
+                       _getlastlogx, _getlastlogxbyname, _getline, _getloadavg, _getlogin, 
+                       _getlogin_r, _getmntinfo, _getmntinfo_r_np, _getmode, _getopt, 
+                       _getopt_long, _getopt_long_only, _getpagesize, _getpass, _getpeereid, 
+                       _getprogname, _gets, _getsourcefilter, _getsubopt, _gettimeofday, 
+                       _getttyent, _getttynam, _getusershell, _getutmp, _getutmpx, 
+                       _getutxent, _getutxent_wtmp, _getutxid, _getutxline, _getvfsbyname, 
+                       _getw, _getwc, _getwc_l, _getwchar, _getwchar_l, _getwd, _glob, 
+                       _glob_b, _globfree, _gmtime, _gmtime_r, _grantpt, _hash_create, 
+                       _hash_destroy, _hash_purge, _hash_search, _hash_stats, _hash_traverse, 
+                       _hcreate, _hdestroy, _heapsort, _heapsort_b, _hsearch, _imaxabs, 
+                       _imaxdiv, _inet_addr, _inet_aton, _inet_lnaof, _inet_makeaddr, 
+                       _inet_net_ntop, _inet_net_pton, _inet_neta, _inet_netof, _inet_network, 
+                       _inet_nsap_addr, _inet_nsap_ntoa, _inet_ntoa, _inet_ntop, 
+                       _inet_ntop4, _inet_ntop6, _inet_pton, _initstate, _insque, 
+                       _isalnum, _isalnum_l, _isalpha, _isalpha_l, _isascii, _isatty, 
+                       _isblank, _isblank_l, _iscntrl, _iscntrl_l, _isdigit, _isdigit_l, 
+                       _isgraph, _isgraph_l, _ishexnumber, _ishexnumber_l, _isideogram, 
+                       _isideogram_l, _islower, _islower_l, _isnumber, _isnumber_l, 
+                       _isphonogram, _isphonogram_l, _isprint, _isprint_l, _ispunct, 
+                       _ispunct_l, _isrune, _isrune_l, _isspace, _isspace_l, _isspecial, 
+                       _isspecial_l, _isupper, _isupper_l, _iswalnum, _iswalnum_l, 
+                       _iswalpha, _iswalpha_l, _iswascii, _iswblank, _iswblank_l, 
+                       _iswcntrl, _iswcntrl_l, _iswctype, _iswctype_l, _iswdigit, 
+                       _iswdigit_l, _iswgraph, _iswgraph_l, _iswhexnumber, _iswhexnumber_l, 
+                       _iswideogram, _iswideogram_l, _iswlower, _iswlower_l, _iswnumber, 
+                       _iswnumber_l, _iswphonogram, _iswphonogram_l, _iswprint, _iswprint_l, 
+                       _iswpunct, _iswpunct_l, _iswrune, _iswrune_l, _iswspace, _iswspace_l, 
+                       _iswspecial, _iswspecial_l, _iswupper, _iswupper_l, _iswxdigit, 
+                       _iswxdigit_l, _isxdigit, _isxdigit_l, _jrand48, _kOSThermalNotificationPressureLevelName, 
+                       _killpg, _l64a, _labs, _lchflags, _lchmod, _lcong48, _ldiv, 
+                       _lfind, _link_addr, _link_ntoa, _llabs, _lldiv, _localeconv, 
+                       _localeconv_l, _localtime, _localtime_r, _lockf, '_lockf$NOCANCEL', 
+                       _login, _login_tty, _logout, _logwtmp, _lrand48, _lsearch, 
+                       _lstatx_np, _lutimes, _mblen, _mblen_l, _mbmb, _mbrlen, _mbrlen_l, 
+                       _mbrrune, _mbrtowc, _mbrtowc_l, _mbrune, _mbsinit, _mbsinit_l, 
+                       _mbsnrtowcs, _mbsnrtowcs_l, _mbsrtowcs, _mbsrtowcs_l, _mbstowcs, 
+                       _mbstowcs_l, _mbtowc, _mbtowc_l, _memmem, _memset_s, _mergesort, 
+                       _mergesort_b, _mkdirx_np, _mkdtemp, _mkdtempat_np, _mkfifox_np, 
+                       _mkostemp, _mkostemps, _mkostempsat_np, _mkpath_np, _mkpathat_np, 
+                       _mkstemp, _mkstemp_dprotected_np, _mkstemps, _mkstempsat_np, 
+                       _mktemp, _mktime, _monaddition, _moncontrol, _moncount, _moninit, 
+                       _monitor, _monoutput, _monreset, _monstartup, _mpool_close, 
+                       _mpool_filter, _mpool_get, _mpool_new, _mpool_open, _mpool_put, 
+                       _mpool_sync, _mrand48, _nanosleep, '_nanosleep$NOCANCEL', 
+                       _new_printf_comp, _new_printf_domain, _newlocale, _nextwctype, 
+                       _nextwctype_l, _nftw, _nice, _nl_langinfo, _nl_langinfo_l, 
+                       _nrand48, _nvis, _off32, _off64, _offtime, _open_memstream, 
+                       _open_with_subsystem, _open_wmemstream, _opendev, _opendir, 
+                       _openpty, _openx_np, _optarg, _opterr, _optind, _optopt, _optreset, 
+                       _pause, '_pause$NOCANCEL', _pclose, _perror, _popen, '_popen$DARWIN_EXTSN', 
+                       _posix2time, _posix_openpt, _posix_spawnp, _printf, _printf_l, 
+                       _psignal, _psort, _psort_b, _psort_r, _ptsname, _ptsname_r, 
+                       _putc, _putc_unlocked, _putchar, _putchar_unlocked, _putenv, 
+                       _puts, _pututxline, _putw, _putwc, _putwc_l, _putwchar, _putwchar_l, 
+                       _qsort, _qsort_b, _qsort_r, _querylocale, _radixsort, _raise, 
+                       _rand, _rand_r, _random, _rb_tree_count, _rb_tree_find_node, 
+                       _rb_tree_find_node_geq, _rb_tree_find_node_leq, _rb_tree_init, 
+                       _rb_tree_insert_node, _rb_tree_iterate, _rb_tree_remove_node, 
+                       _readdir, _readdir_r, _readpassphrase, _reallocf, _realpath, 
+                       '_realpath$DARWIN_EXTSN', _recv, '_recv$NOCANCEL', _regcomp, 
+                       _regcomp_l, _regerror, _regexec, _regfree, _register_printf_domain_function, 
+                       _register_printf_domain_render_std, _regncomp, _regncomp_l, 
+                       _regnexec, _regwcomp, _regwcomp_l, _regwexec, _regwncomp, 
+                       _regwncomp_l, _regwnexec, _remove, _remque, _rewind, _rewinddir, 
+                       _rindex, _rpmatch, _sbrk, _scandir, _scandir_b, _scanf, _scanf_l, 
+                       _seed48, _seekdir, _send, '_send$NOCANCEL', _setbuf, _setbuffer, 
+                       _setenv, _sethostid, _sethostname, _setinvalidrune, _setipv4sourcefilter, 
+                       _setkey, _setlinebuf, _setlocale, _setlogin, _setmode, _setpgrp, 
+                       _setprogname, _setrgid, _setruid, _setrunelocale, _setsourcefilter, 
+                       _setstate, _settimeofday, _setttyent, _setusershell, _setutxent, 
+                       _setutxent_wtmp, _setvbuf, _sigaction, _sigaddset, _sigaltstack, 
+                       _sigblock, _sigdelset, _sigemptyset, _sigfillset, _sighold, 
+                       _sigignore, _siginterrupt, _sigismember, _signal, _sigpause, 
+                       '_sigpause$NOCANCEL', _sigrelse, _sigset, _sigsetmask, _sigvec, 
+                       _skip, _sl_add, _sl_find, _sl_free, _sl_init, _sleep, '_sleep$NOCANCEL', 
+                       _snprintf, _snprintf_l, _snvis, _sockatmark, _sprintf, _sprintf_l, 
+                       _sradixsort, _srand, _srand48, _sranddev, _srandom, _srandomdev, 
+                       _sscanf, _sscanf_l, _stat_with_subsystem, _statvfs, _statx_np, 
+                       _stpcpy, _stpncpy, _stravis, _strcasecmp, _strcasecmp_l, _strcasestr, 
+                       _strcasestr_l, _strcat, _strcoll, _strcoll_l, _strcspn, _strdup, 
+                       _strenvisx, _strerror, _strerror_r, _strfmon, _strfmon_l, 
+                       _strftime, _strftime_l, _strmode, _strncasecmp, _strncasecmp_l, 
+                       _strncat, _strndup, _strnstr, _strnunvis, _strnunvisx, _strnvis, 
+                       _strnvisx, _strpbrk, _strptime, _strptime_l, _strrchr, _strsenvisx, 
+                       _strsep, _strsignal, _strsignal_r, _strsnvis, _strsnvisx, 
+                       _strspn, _strsvis, _strsvisx, _strtod, _strtod_l, _strtof, 
+                       _strtof_l, _strtofflags, _strtoimax, _strtoimax_l, _strtok, 
+                       _strtok_r, _strtol, _strtol_l, _strtold, _strtold_l, _strtoll, 
+                       _strtoll_l, _strtonum, _strtoq, _strtoq_l, _strtoul, _strtoul_l, 
+                       _strtoull, _strtoull_l, _strtoumax, _strtoumax_l, _strtouq, 
+                       _strtouq_l, _strunvis, _strunvisx, _strvis, _strvisx, _strxfrm, 
+                       _strxfrm_l, _suboptarg, _svis, _swab, _swprintf, _swprintf_l, 
+                       _swscanf, _swscanf_l, _sxprintf, _sxprintf_exec, _sync_volume_np, 
+                       _sys_errlist, _sys_nerr, _sys_siglist, _sys_signame, _sysconf, 
+                       _sysctl, _sysctlbyname, _sysctlnametomib, _system, '_system$NOCANCEL', 
+                       _tcdrain, '_tcdrain$NOCANCEL', _tcflow, _tcflush, _tcgetattr, 
+                       _tcgetpgrp, _tcgetsid, _tcsendbreak, _tcsetattr, _tcsetpgrp, 
+                       _tdelete, _telldir, _tempnam, _tfind, _thread_stack_async_pcs, 
+                       _thread_stack_pcs, _time, _time2posix, _timegm, _timelocal, 
+                       _timeoff, _times, _timespec_get, _timezone, _timingsafe_bcmp, 
+                       _tmpfile, _tmpnam, _toascii, _tolower, _tolower_l, _toupper, 
+                       _toupper_l, _towctrans, _towctrans_l, _towlower, _towlower_l, 
+                       _towupper, _towupper_l, _tre_ast_new_catenation, _tre_ast_new_iter, 
+                       _tre_ast_new_literal, _tre_ast_new_node, _tre_ast_new_union, 
+                       _tre_compile, _tre_fill_pmatch, _tre_free, _tre_mem_alloc_impl, 
+                       _tre_mem_destroy, _tre_mem_new_impl, _tre_parse, _tre_stack_destroy, 
+                       _tre_stack_new, _tre_stack_num_objects, _tre_tnfa_run_backtrack, 
+                       _tre_tnfa_run_parallel, _tsearch, _ttyname, _ttyname_r, _ttyslot, 
+                       _twalk, _tzname, _tzset, _tzsetwall, _ualarm, _ulimit, _umaskx_np, 
+                       _uname, _ungetc, _ungetwc, _ungetwc_l, _unlockpt, _unsetenv, 
+                       _unvis, _uselocale, _usleep, '_usleep$NOCANCEL', _utime, _utmpxname, 
+                       _uuid_clear, _uuid_compare, _uuid_copy, _uuid_generate, _uuid_generate_random, 
+                       _uuid_generate_time, _uuid_is_null, _uuid_pack, _uuid_parse, 
+                       _uuid_unpack, _uuid_unparse, _uuid_unparse_lower, _uuid_unparse_upper, 
+                       _vasprintf, _vasprintf_l, _vasxprintf, _vasxprintf_exec, _vdprintf, 
+                       _vdprintf_l, _vdxprintf, _vdxprintf_exec, _verr, _verrc, _verrx, 
+                       _vfork, _vfprintf, _vfprintf_l, _vfscanf, _vfscanf_l, _vfwprintf, 
+                       _vfwprintf_l, _vfwscanf, _vfwscanf_l, _vfxprintf, _vfxprintf_exec, 
+                       _vis, _vprintf, _vprintf_l, _vscanf, _vscanf_l, _vsnprintf, 
+                       _vsnprintf_l, _vsprintf, _vsprintf_l, _vsscanf, _vsscanf_l, 
+                       _vswprintf, _vswprintf_l, _vswscanf, _vswscanf_l, _vsxprintf, 
+                       _vsxprintf_exec, _vwarn, _vwarnc, _vwarnx, _vwprintf, _vwprintf_l, 
+                       _vwscanf, _vwscanf_l, _vxprintf, _vxprintf_exec, _wait, '_wait$NOCANCEL', 
+                       _wait3, _waitpid, '_waitpid$NOCANCEL', _warn, _warnc, _warnx, 
+                       _wcpcpy, _wcpncpy, _wcrtomb, _wcrtomb_l, _wcscasecmp, _wcscasecmp_l, 
+                       _wcscat, _wcschr, _wcscmp, _wcscoll, _wcscoll_l, _wcscpy, 
+                       _wcscspn, _wcsdup, _wcsftime, _wcsftime_l, _wcslcat, _wcslcpy, 
+                       _wcslen, _wcsncasecmp, _wcsncasecmp_l, _wcsncat, _wcsncmp, 
+                       _wcsncpy, _wcsnlen, _wcsnrtombs, _wcsnrtombs_l, _wcspbrk, 
+                       _wcsrchr, _wcsrtombs, _wcsrtombs_l, _wcsspn, _wcsstr, _wcstod, 
+                       _wcstod_l, _wcstof, _wcstof_l, _wcstoimax, _wcstoimax_l, _wcstok, 
+                       _wcstol, _wcstol_l, _wcstold, _wcstold_l, _wcstoll, _wcstoll_l, 
+                       _wcstombs, _wcstombs_l, _wcstoul, _wcstoul_l, _wcstoull, _wcstoull_l, 
+                       _wcstoumax, _wcstoumax_l, _wcswidth, _wcswidth_l, _wcsxfrm, 
+                       _wcsxfrm_l, _wctob, _wctob_l, _wctomb, _wctomb_l, _wctrans, 
+                       _wctrans_l, _wctype, _wctype_l, _wcwidth, _wcwidth_l, _wmemchr, 
+                       _wmemcmp, _wmemcpy, _wmemmove, _wmemset, _wordexp, _wordfree, 
+                       _wprintf, _wprintf_l, _wscanf, _wscanf_l, _wtmpxname, _xprintf, 
+                       _xprintf_exec ]
+reexports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _bcmp, _bzero, _index, _memccpy, _memchr, _memcmp, _memcpy, 
+                       _memmove, _memset, _memset_pattern16, _memset_pattern4, _memset_pattern8, 
+                       _strchr, _strcmp, _strcpy, _strlcat, _strlcpy, _strlen, _strncmp, 
+                       _strncpy, _strnlen, _strstr ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           308C9B23-5690-30DE-8008-0C50E7C725C5
+  - target:          x86_64-maccatalyst
+    value:           308C9B23-5690-30DE-8008-0C50E7C725C5
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           89E9EF9E-ED46-307F-B973-6B5C3FB67388
+  - target:          arm64e-maccatalyst
+    value:           89E9EF9E-ED46-307F-B973-6B5C3FB67388
+install-name:    '/usr/lib/system/libsystem_collections.dylib'
+current-version: 1534.40.2
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _os_map_128_clear, _os_map_128_count, _os_map_128_delete, 
+                       _os_map_128_destroy, _os_map_128_find, _os_map_128_foreach, 
+                       _os_map_128_init, _os_map_128_insert, _os_map_32_clear, _os_map_32_count, 
+                       _os_map_32_delete, _os_map_32_destroy, _os_map_32_find, _os_map_32_foreach, 
+                       _os_map_32_init, _os_map_32_insert, _os_map_64_clear, _os_map_64_count, 
+                       _os_map_64_delete, _os_map_64_destroy, _os_map_64_find, _os_map_64_foreach, 
+                       _os_map_64_init, _os_map_64_insert, _os_map_str_clear, _os_map_str_count, 
+                       _os_map_str_delete, _os_map_str_destroy, _os_map_str_entry, 
+                       _os_map_str_find, _os_map_str_foreach, _os_map_str_init, _os_map_str_insert, 
+                       _os_set_32_ptr_clear, _os_set_32_ptr_count, _os_set_32_ptr_delete, 
+                       _os_set_32_ptr_destroy, _os_set_32_ptr_find, _os_set_32_ptr_foreach, 
+                       _os_set_32_ptr_init, _os_set_32_ptr_insert, _os_set_64_ptr_clear, 
+                       _os_set_64_ptr_count, _os_set_64_ptr_delete, _os_set_64_ptr_destroy, 
+                       _os_set_64_ptr_find, _os_set_64_ptr_foreach, _os_set_64_ptr_init, 
+                       _os_set_64_ptr_insert, _os_set_str_ptr_clear, _os_set_str_ptr_count, 
+                       _os_set_str_ptr_delete, _os_set_str_ptr_destroy, _os_set_str_ptr_find, 
+                       _os_set_str_ptr_foreach, _os_set_str_ptr_init, _os_set_str_ptr_insert ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           1CCF39AE-1799-327F-BFA5-5CBBC9511318
+  - target:          x86_64-maccatalyst
+    value:           1CCF39AE-1799-327F-BFA5-5CBBC9511318
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           3C081A70-EBBF-3746-A83F-FC93891BAA71
+  - target:          arm64e-maccatalyst
+    value:           3C081A70-EBBF-3746-A83F-FC93891BAA71
+install-name:    '/usr/lib/system/libsystem_configuration.dylib'
+current-version: 1241.40.2
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ __dns_configuration_ack, __libSC_info_fork_child, __libSC_info_fork_parent, 
+                       __libSC_info_fork_prepare, __nwi_config_agent_copy_data, __nwi_state_ack, 
+                       __nwi_state_force_refresh, _config_agent_copy_dns_information, 
+                       _config_agent_copy_proxy_information, _config_agent_free_dns_information, 
+                       _config_agent_free_proxy_information, _config_agent_get_dns_nameservers, 
+                       _config_agent_get_dns_searchdomains, _config_agent_update_proxy_information, 
+                       _dns_configuration_copy, _dns_configuration_free, _dns_configuration_notify_key, 
+                       _is_config_agent_type_dns, _is_config_agent_type_proxy, _nwi_ifstate_compare_rank, 
+                       _nwi_ifstate_get_dns_signature, _nwi_ifstate_get_flags, _nwi_ifstate_get_generation, 
+                       _nwi_ifstate_get_ifname, _nwi_ifstate_get_next, _nwi_ifstate_get_reachability_flags, 
+                       _nwi_ifstate_get_signature, _nwi_ifstate_get_vpn_server, _nwi_state_copy, 
+                       _nwi_state_get_first_ifstate, _nwi_state_get_generation, _nwi_state_get_ifstate, 
+                       _nwi_state_get_interface_names, _nwi_state_get_notify_key, 
+                       _nwi_state_get_reachability_flags, _nwi_state_release ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           B94F5292-7CDC-368F-8D91-0CD73AE80924
+  - target:          x86_64-maccatalyst
+    value:           B94F5292-7CDC-368F-8D91-0CD73AE80924
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           D48AD081-4875-3F66-ABE1-9B646DD03B9C
+  - target:          arm64e-maccatalyst
+    value:           D48AD081-4875-3F66-ABE1-9B646DD03B9C
+install-name:    '/usr/lib/system/libsystem_containermanager.dylib'
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _CONTAINER_CURRENT_MOBILE_UID, _CONTAINER_INSTALLATION_UID, 
+                       _CONTAINER_LINK_ARRAY_NONE, _CONTAINER_NOTIFY_USER_INVALIDATED, 
+                       _CONTAINER_PERSONA_CURRENT, _CONTAINER_PERSONA_PRIMARY, _CONTAINER_SYSTEM_UID, 
+                       __container_init, __container_query_get_servicing_pid, __container_references_get_servicing_pid, 
+                       _container_acquire_sandbox_extension, _container_audit_token_copy_codesign_hash, 
+                       _container_audit_token_copy_codesign_identifier, _container_audit_token_copy_entitlement, 
+                       _container_audit_token_copy_executable_name, _container_audit_token_for_pid, 
+                       _container_audit_token_get_codesign_status, _container_audit_token_get_egid, 
+                       _container_audit_token_get_euid, _container_audit_token_get_pid, 
+                       _container_audit_token_get_platform, _container_audit_token_is_valid, 
+                       _container_base64_decode, _container_base64_decode_string, 
+                       _container_base64_encode, _container_base64_encode_string, 
+                       _container_bundle_copy_data_container, _container_bundle_copy_data_container_path, 
+                       _container_class_for_each_normalized_class, _container_class_normalized, 
+                       _container_class_supports_data_subdirectory, _container_class_supports_randomized_path, 
+                       _container_class_supports_randomized_path_on_current_platform, 
+                       _container_client_copy_decoded_from_xpc_object, _container_client_copy_encoded_xpc_object, 
+                       _container_client_copy_entitlement, _container_client_create_from_audit_token, 
+                       _container_client_get_audit_token, _container_client_get_codesign_identifier, 
+                       _container_client_get_egid, _container_client_get_euid, _container_client_get_persona_unique_string, 
+                       _container_client_get_pid, _container_client_get_platform, 
+                       _container_client_initializer, _container_client_is_alive, 
+                       _container_client_is_platform_binary, _container_client_is_sandboxed, 
+                       _container_client_is_signature_valid, _container_client_is_signed, 
+                       _container_client_is_test_client, _container_codesign_copy_cdhash, 
+                       _container_codesign_copy_cs_identity, _container_codesign_copy_current_identifier, 
+                       _container_codesign_get_self_audit_token, _container_codesign_get_status, 
+                       _container_copy_client, _container_copy_code_signing_info_for_identifier, 
+                       _container_copy_from_path, _container_copy_info, _container_copy_info_value_for_key, 
+                       _container_copy_links_array, _container_copy_object, _container_copy_path, 
+                       _container_copy_persona_unique_strings, _container_copy_sandbox_token, 
+                       _container_copy_unlocalized_description, _container_create_merged_array, 
+                       _container_create_or_lookup, _container_create_or_lookup_app_group_path_by_app_group_identifier, 
+                       _container_create_or_lookup_app_group_paths, _container_create_or_lookup_app_group_paths_for_current_user, 
+                       _container_create_or_lookup_app_group_paths_for_platform, 
+                       _container_create_or_lookup_app_group_paths_from_entitlements, 
+                       _container_create_or_lookup_for_current_user, _container_create_or_lookup_for_platform, 
+                       _container_create_or_lookup_group_container_paths_for_current_user, 
+                       _container_create_or_lookup_path, _container_create_or_lookup_path_for_current_user, 
+                       _container_create_or_lookup_path_for_platform, _container_create_or_lookup_system_group_paths, 
+                       _container_create_or_lookup_user_managed_assets_path, _container_create_or_lookup_user_managed_assets_relative_path, 
+                       _container_delete, _container_delete_all_container_content, 
+                       _container_delete_all_data_container_content, _container_delete_all_data_container_content_for_current_user, 
+                       _container_delete_array_of_containers, _container_delete_user_managed_assets, 
+                       _container_delete_with_class_and_identifier_for_current_user, 
+                       _container_delete_with_uid_class_and_identifier, _container_disk_usage, 
+                       _container_disposition, _container_disposition_for_array, 
+                       _container_error_copy, _container_error_copy_unlocalized_description, 
+                       _container_error_create, _container_error_free, _container_error_get_category, 
+                       _container_error_get_path, _container_error_get_posix_errno, 
+                       _container_error_get_type, _container_error_is_fatal, _container_error_is_file_system_error, 
+                       _container_error_reinitialize, _container_flush_container_cache, 
+                       _container_flush_persona_cache, _container_free_array_of_containers, 
+                       _container_free_client, _container_free_object, _container_frozenset_copyout_external_bytes, 
+                       _container_frozenset_create, _container_frozenset_create_from_external_bytes, 
+                       _container_frozenset_destroy, _container_frozenset_enumerate_matches, 
+                       _container_frozenset_get_container_class_of_container_at_index, 
+                       _container_frozenset_get_count, _container_frozenset_get_extended_count, 
+                       _container_frozenset_get_generation, _container_frozenset_get_identifier_of_container_at_index, 
+                       _container_frozenset_get_is_new_of_container_at_index, _container_frozenset_get_is_transient_of_container_at_index, 
+                       _container_frozenset_get_links_for_container_at_index, _container_frozenset_get_path_of_container_at_index, 
+                       _container_frozenset_get_persona_unique_string_of_container_at_index, 
+                       _container_frozenset_get_uid_of_container_at_index, _container_frozenset_get_unique_path_component_of_container_at_index, 
+                       _container_frozenset_get_uuid_of_container_at_index, _container_frozenset_is_missing_links_of_container_at_index, 
+                       _container_frozenset_is_missing_path_of_container_at_index, 
+                       _container_fs_add_path_component, _container_fs_append_trailing_slash, 
+                       _container_fs_item_exists, _container_fs_item_exists_at, _container_fs_load_plist_at, 
+                       _container_fs_path_at, _container_fs_resolve_dirent_type_at, 
+                       _container_get_all_with_class, _container_get_all_with_class_for_current_user, 
+                       _container_get_class, _container_get_error_description, _container_get_identifier, 
+                       _container_get_path, _container_get_persona_unique_string, 
+                       _container_get_uid, _container_get_unique_path_component, 
+                       _container_group_container_identifiers_for_current_user, _container_internal_get_first_boot_uuid, 
+                       _container_invalidate_code_signing_cache, _container_is_equal, 
+                       _container_is_new, _container_is_transient, _container_link_apply, 
+                       _container_link_copy, _container_link_copy_array, _container_link_copy_container_a, 
+                       _container_link_copy_container_b, _container_link_copy_unlocalized_description, 
+                       _container_link_create, _container_link_create_internal, _container_link_exists, 
+                       _container_link_free, _container_link_free_array, _container_link_get_attributes, 
+                       _container_link_is_implicit, _container_link_remove, _container_log_client_fault_logging_is_enabled, 
+                       _container_log_error, _container_log_error_with_faults, _container_log_ext_error, 
+                       _container_log_ext_error_with_faults, _container_log_handle_for_category, 
+                       _container_log_set_client_fault_logging, _container_object_copy, 
+                       _container_object_create, _container_object_create_blank, 
+                       _container_object_free, _container_object_get_class, _container_object_get_identifier, 
+                       _container_object_get_info, _container_object_get_links, _container_object_get_num_links, 
+                       _container_object_get_path, _container_object_get_persona_unique_string, 
+                       _container_object_get_query, _container_object_get_sandbox_token, 
+                       _container_object_get_uid, _container_object_get_unique_path_component, 
+                       _container_object_get_uuid, _container_object_is_new, _container_object_is_transient, 
+                       _container_object_sandbox_extension_activate, _container_object_set_backing_store_from_query, 
+                       _container_object_set_class, _container_object_set_info, _container_object_set_links, 
+                       _container_object_set_path, _container_object_set_sandbox_token, 
+                       _container_object_set_transient, _container_object_set_unique_path_component, 
+                       _container_object_set_uuid, _container_object_update_metadata, 
+                       _container_operation_complete_background_tasks, _container_operation_delete, 
+                       _container_operation_delete_array, _container_operation_delete_reclaim_disk_space, 
+                       _container_paths_context_create, _container_paths_context_free, 
+                       _container_paths_context_set_class, _container_paths_context_set_flags, 
+                       _container_paths_context_set_persona_unique_string, _container_paths_context_set_transient, 
+                       _container_paths_context_set_uid, _container_paths_copy_container_at, 
+                       _container_paths_copy_container_from_path, _container_paths_copy_container_root_path_for_context, 
+                       _container_paths_enumerate_containers_at, _container_perfect_hash_copyout_external_bytes, 
+                       _container_perfect_hash_count, _container_perfect_hash_create, 
+                       _container_perfect_hash_create_from_external_bytes, _container_perfect_hash_destroy, 
+                       _container_perfect_hash_index_of, _container_perfect_hash_num_indexes, 
+                       _container_perform_data_migration, _container_perform_data_migration_for_current_user, 
+                       _container_perform_with_client_context, _container_persona_verify_path_for_current_persona, 
+                       _container_process_restored_container, _container_pwd_copy_user_home_path, 
+                       _container_query_copy, _container_query_count_results, _container_query_create, 
+                       _container_query_create_from_container, _container_query_free, 
+                       _container_query_get_last_error, _container_query_get_single_result, 
+                       _container_query_iterate_results_sync, _container_query_iterate_results_with_subquery_sync, 
+                       _container_query_operation_set_client, _container_query_operation_set_flags, 
+                       _container_query_operation_set_platform, _container_query_set_class, 
+                       _container_query_set_group_identifiers, _container_query_set_identifiers, 
+                       _container_query_set_include_other_owners, _container_query_set_links, 
+                       _container_query_set_persona_unique_string, _container_query_set_transient, 
+                       _container_query_set_uid, _container_realpath, _container_recreate_structure, 
+                       _container_references_add, _container_references_create, _container_references_free, 
+                       _container_references_get_last_error, _container_references_iterate_by_group_sync, 
+                       _container_references_iterate_by_owner_sync, _container_references_operation_set_flags, 
+                       _container_references_remove, _container_references_set_class, 
+                       _container_references_set_persona_unique_string, _container_references_set_uid, 
+                       _container_regenerate_uuid, _container_repair_user_data, _container_replace, 
+                       _container_retry_test, _container_sandbox_extension_consume, 
+                       _container_sandbox_extension_revoke, _container_sandbox_issue_custom_extension, 
+                       _container_sandbox_issue_extension, _container_serialize_copy_deserialized_reference, 
+                       _container_serialize_copy_serialized_reference, _container_set_code_signing_info_for_identifier, 
+                       _container_set_data_protection_for_current_user, _container_set_info_value, 
+                       _container_set_test_lock, _container_stage_shared_system_content, 
+                       _container_string_rom_copyout_external_bytes, _container_string_rom_count, 
+                       _container_string_rom_create, _container_string_rom_create_from_external_bytes, 
+                       _container_string_rom_destroy, _container_string_rom_index_of, 
+                       _container_string_rom_string_at_index, _container_subdirectories_for_class, 
+                       _container_system_group_path_for_identifier, _container_system_path_for_identifier, 
+                       _container_update_with_container, _container_user_managed_assets_path, 
+                       _container_user_managed_assets_relative_path, _container_xpc_connection_is_shared, 
+                       _container_xpc_create_connection, _container_xpc_decode_container_object, 
+                       _container_xpc_decode_create_container_object_array, _container_xpc_decode_create_link, 
+                       _container_xpc_decode_create_links_array, _container_xpc_decode_error, 
+                       _container_xpc_encode_client_onto_message, _container_xpc_encode_container_array, 
+                       _container_xpc_encode_container_as_object, _container_xpc_encode_container_metadata_as_object, 
+                       _container_xpc_encode_container_object, _container_xpc_encode_error, 
+                       _container_xpc_encode_error_as_object, _container_xpc_encode_link, 
+                       _container_xpc_encode_link_as_object, _container_xpc_get_raw_connection, 
+                       _container_xpc_invalidate_connection, _container_xpc_release, 
+                       _container_xpc_send_async_message, _container_xpc_send_sync_message, 
+                       _container_xpc_send_sync_message_with_object, _container_xpc_set_client_context_during_block, 
+                       _container_xpc_set_use_shared_connection, _container_xpc_shared_copy_connection ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           47275741-03DA-37A9-85B9-541F4DCB1163
+  - target:          x86_64-maccatalyst
+    value:           47275741-03DA-37A9-85B9-541F4DCB1163
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           9F1BA0E0-8227-364B-8CF4-86D6870D6937
+  - target:          arm64e-maccatalyst
+    value:           9F1BA0E0-8227-364B-8CF4-86D6870D6937
+install-name:    '/usr/lib/system/libsystem_coreservices.dylib'
+current-version: 129
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _NSGetNextSearchPathEnumeration, _NSStartSearchPathEnumeration, 
+                       _NSStartSearchPathEnumerationPrivate, ___user_local_dirname, 
+                       ___user_relative_dirname, __append_relative_path_component, 
+                       __dirhelper, __dirhelper_relative, __get_user_dir_suffix, 
+                       __libcoreservices_fork_child, __set_user_dir_suffix, _sysdir_get_next_search_path_enumeration, 
+                       _sysdir_start_search_path_enumeration, _sysdir_start_search_path_enumeration_private ]
+  - targets:         [ x86_64-macos, arm64-macos, arm64e-macos ]
+    symbols:         [ __idle_exit ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           4B2F10CE-2D99-3B79-A05A-87DD03065ACB
+  - target:          x86_64-maccatalyst
+    value:           4B2F10CE-2D99-3B79-A05A-87DD03065ACB
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           859E9F1E-85E4-3469-9733-5846C98B155D
+  - target:          arm64e-maccatalyst
+    value:           859E9F1E-85E4-3469-9733-5846C98B155D
+install-name:    '/usr/lib/system/libsystem_darwin.dylib'
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ ___libdarwin_init, ___os_temporary_resource_shortage, _claimfd_np, 
+                       _close_drop_np, _close_drop_optional_np, _crfprintf_np, _dirstat_np, 
+                       _dirstatat_np, _dup_np, _err_np, _errc_np, _fcheck_np, _memdup2_np, 
+                       _memdup_np, _os_assert_mach, _os_assert_mach_port_status, 
+                       _os_boot_arg_string_to_int, _os_boot_mode_query, _os_crash_get_reporter_port_array, 
+                       _os_crash_port_array_deallocate, _os_crash_set_reporter_port, 
+                       _os_crash_spawnattr_set_reporter_port, _os_enumerate_boot_args, 
+                       _os_enumerate_boot_args_b, _os_enumerate_boot_args_from_buffer, 
+                       _os_enumerate_boot_args_from_buffer_b, _os_flagset_copy_string, 
+                       _os_localtime_file, _os_mach_msg_copy_description, _os_mach_msg_get_audit_trailer, 
+                       _os_mach_msg_get_context_trailer, _os_mach_msg_get_trailer, 
+                       _os_mach_msg_trailer_copy_description, _os_mach_port_copy_description, 
+                       _os_parse_boot_arg_from_buffer_int, _os_parse_boot_arg_from_buffer_string, 
+                       _os_parse_boot_arg_int, _os_parse_boot_arg_string, _os_simple_hash, 
+                       _os_simple_hash_string, _os_simple_hash_string_with_seed, 
+                       _os_simple_hash_with_seed, _os_subcommand_fprintf, _os_subcommand_main, 
+                       _os_subcommand_vfprintf, _os_variant_allows_internal_security_policies, 
+                       _os_variant_allows_security_research, _os_variant_check, _os_variant_copy_description, 
+                       _os_variant_has_factory_content, _os_variant_has_internal_content, 
+                       _os_variant_has_internal_diagnostics, _os_variant_has_internal_ui, 
+                       _os_variant_init_4launchd, _os_variant_is_basesystem, _os_variant_is_darwinos, 
+                       _os_variant_is_recovery, _os_variant_uses_ephemeral_storage, 
+                       _realpath_np, _strerror_np, _strexit_np, _symerror_np, _symexit_np, 
+                       _sysctl_get_data_np, _sysctlbyname_get_data_np, _sysexit_np, 
+                       _vcrfprintf_np, _verr_np, _verrc_np, _vwarn_np, _vwfprintf_np, 
+                       _warn_np, _wfprintf_np, _xferfd_np, _zsnprintf_np ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           C352C6E4-8236-3B91-8ECA-4692191DD227
+  - target:          x86_64-maccatalyst
+    value:           C352C6E4-8236-3B91-8ECA-4692191DD227
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           1122C71F-CFA3-38EB-A329-C647E500C9B1
+  - target:          arm64e-maccatalyst
+    value:           1122C71F-CFA3-38EB-A329-C647E500C9B1
+install-name:    '/usr/lib/system/libsystem_dnssd.dylib'
+current-version: 1790.40.31
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _DNSServiceAddRecord, _DNSServiceAttrCreate, _DNSServiceAttrFree, 
+                       _DNSServiceAttrSetFailoverPolicy, _DNSServiceAttrSetValidationData, 
+                       _DNSServiceAttrSetValidationPolicy, _DNSServiceAttributeCreate, 
+                       _DNSServiceAttributeDeallocate, _DNSServiceAttributeSetAAAAPolicy, 
+                       _DNSServiceAttributeSetTimestamp, _DNSServiceBrowse, _DNSServiceBrowseEx, 
+                       _DNSServiceConstructFullName, _DNSServiceCreateConnection, 
+                       _DNSServiceCreateDelegateConnection, _DNSServiceEnumerateDomains, 
+                       _DNSServiceErrorCodeToString, _DNSServiceGetAddrInfo, _DNSServiceGetAddrInfoEx, 
+                       _DNSServiceGetPID, _DNSServiceGetProperty, _DNSServiceGetValidationData, 
+                       _DNSServiceNATPortMappingCreate, _DNSServiceProcessResult, 
+                       _DNSServiceQueryRecord, _DNSServiceQueryRecordEx, _DNSServiceQueryRecordWithAttribute, 
+                       _DNSServiceReconfirmRecord, _DNSServiceRefDeallocate, _DNSServiceRefSockFD, 
+                       _DNSServiceRegister, _DNSServiceRegisterRecord, _DNSServiceRegisterRecordWithAttribute, 
+                       _DNSServiceRegisterWithAttribute, _DNSServiceRemoveRecord, 
+                       _DNSServiceResolve, _DNSServiceResolveEx, _DNSServiceSendQueuedRequests, 
+                       _DNSServiceSetDefaultDomainForUser, _DNSServiceSetDispatchQueue, 
+                       _DNSServiceSetResolverDefaults, _DNSServiceSleepKeepalive, 
+                       _DNSServiceSleepKeepalive_sockaddr, _DNSServiceUpdateRecord, 
+                       _DNSServiceUpdateRecordWithAttribute, _PeerConnectionRelease, 
+                       _TXTRecordContainsKey, _TXTRecordCreate, _TXTRecordDeallocate, 
+                       _TXTRecordGetBytesPtr, _TXTRecordGetCount, _TXTRecordGetItemAtIndex, 
+                       _TXTRecordGetLength, _TXTRecordGetValuePtr, _TXTRecordRemoveValue, 
+                       _TXTRecordSetValue, _kDNSServiceAttrAllowFailover, _kDNSServiceAttrValidationRequired, 
+                       _kDNSServiceAttributeAAAAFallback ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           2AF1974D-3A00-3461-9FDB-AF641DE4253E
+  - target:          x86_64-maccatalyst
+    value:           2AF1974D-3A00-3461-9FDB-AF641DE4253E
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           C50ECE78-12CE-377F-93BA-B0D8B0D93CE7
+  - target:          arm64e-maccatalyst
+    value:           C50ECE78-12CE-377F-93BA-B0D8B0D93CE7
+install-name:    '/usr/lib/system/libsystem_featureflags.dylib'
+current-version: 71
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ __os_feature_enabled_impl, __os_feature_enabled_simple_impl ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           37924254-46CA-3531-9BE4-E9782F4DA626
+  - target:          x86_64-maccatalyst
+    value:           37924254-46CA-3531-9BE4-E9782F4DA626
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           177AEA65-CA0C-38EB-8891-7726D30EC0AB
+  - target:          arm64e-maccatalyst
+    value:           177AEA65-CA0C-38EB-8891-7726D30EC0AB
+install-name:    '/usr/lib/system/libsystem_info.dylib'
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _LI_get_thread_item, _LI_get_thread_list, _LI_ils_create, 
+                       _LI_set_thread_item, _LI_set_thread_list, ___dn_skipname, 
+                       __authenticate, __ds_running, __gai_nat64_can_v4_address_be_synthesized, 
+                       __gai_serv_to_port, __gai_simple, __getaddrinfo_interface_async_call, 
+                       __getlong, __getnameinfo_interface_async_call, __getshort, 
+                       __null_auth, __res, __seterr_reply, __si_disable_opendirectory, 
+                       __yp_dobind, _alias_endent, _alias_getbyname, _alias_getent, 
+                       _alias_setent, _authnone_create, _authunix_create, _authunix_create_default, 
+                       _bindresvport, _bindresvport_sa, _bootparams_endent, _bootparams_getbyname, 
+                       _bootparams_getent, _bootparams_setent, _clnt_broadcast, _clnt_create, 
+                       _clnt_pcreateerror, _clnt_perrno, _clnt_perror, _clnt_spcreateerror, 
+                       _clnt_sperrno, _clnt_sperror, _clntraw_create, _clnttcp_create, 
+                       _clntudp_bufcreate, _clntudp_create, _configuration_profile_copy_property_list, 
+                       _configuration_profile_create_notification_key, _dn_expand, 
+                       _endfsent, _endgrent, _endhostent, _endnetent, _endnetgrent, 
+                       _endprotoent, _endpwent, _endrpcent, _endservent, _ether_aton, 
+                       _ether_hostton, _ether_line, _ether_ntoa, _ether_ntohost, 
+                       _freeaddrinfo, _freehostent, _freeifaddrs, _freeifmaddrs, 
+                       _gL1CacheEnabled, _gai_strerror, _getaddrinfo, _getaddrinfo_async_cancel, 
+                       _getaddrinfo_async_handle_reply, _getaddrinfo_async_receive, 
+                       _getaddrinfo_async_send, _getaddrinfo_async_start, _getdomainname, 
+                       _getfsent, _getfsfile, _getfsspec, _getgrent, _getgrgid, _getgrgid_r, 
+                       _getgrnam, _getgrnam_r, _getgroupcount, _getgrouplist, _getgrouplist_2, 
+                       _getgruuid, _getgruuid_r, _gethostbyaddr, _gethostbyaddr_async_cancel, 
+                       _gethostbyaddr_async_handleReply, _gethostbyaddr_async_start, 
+                       _gethostbyname, _gethostbyname2, _gethostbyname_async_cancel, 
+                       _gethostbyname_async_handleReply, _gethostbyname_async_start, 
+                       _gethostent, _getifaddrs, _getifmaddrs, _getipnodebyaddr, 
+                       _getipnodebyname, _getnameinfo, _getnameinfo_async_cancel, 
+                       _getnameinfo_async_handle_reply, _getnameinfo_async_send, 
+                       _getnameinfo_async_start, _getnetbyaddr, _getnetbyname, _getnetent, 
+                       _getnetgrent, _getprotobyname, _getprotobynumber, _getprotoent, 
+                       _getpwent, _getpwnam, _getpwnam_r, _getpwuid, _getpwuid_r, 
+                       _getpwuuid, _getpwuuid_r, _getrpcbyname, _getrpcbynumber, 
+                       _getrpcent, _getrpcport, _getservbyname, _getservbyport, _getservent, 
+                       _group_from_gid, _h_errno, _herror, _hstrerror, _htonl, _htons, 
+                       _if_freenameindex, _if_indextoname, _if_nameindex, _if_nametoindex, 
+                       _in6addr_any, _in6addr_linklocal_allnodes, _in6addr_linklocal_allrouters, 
+                       _in6addr_linklocal_allv2routers, _in6addr_loopback, _in6addr_nodelocal_allnodes, 
+                       _inet6_opt_append, _inet6_opt_find, _inet6_opt_finish, _inet6_opt_get_val, 
+                       _inet6_opt_init, _inet6_opt_next, _inet6_opt_set_val, _inet6_option_alloc, 
+                       _inet6_option_append, _inet6_option_find, _inet6_option_init, 
+                       _inet6_option_next, _inet6_option_space, _inet6_rth_add, _inet6_rth_getaddr, 
+                       _inet6_rth_init, _inet6_rth_reverse, _inet6_rth_segments, 
+                       _inet6_rth_space, _inet6_rthdr_add, _inet6_rthdr_getaddr, 
+                       _inet6_rthdr_getflags, _inet6_rthdr_init, _inet6_rthdr_lasthop, 
+                       _inet6_rthdr_segments, _inet6_rthdr_space, _initgroups, _innetgr, 
+                       _iruserok, _iruserok_sa, _kvarray_free, _kvbuf_add_dict, _kvbuf_add_key, 
+                       _kvbuf_add_val, _kvbuf_add_val_len, _kvbuf_append_kvbuf, _kvbuf_decode, 
+                       _kvbuf_free, _kvbuf_get_len, _kvbuf_init, _kvbuf_init_zone, 
+                       _kvbuf_make_nonpurgeable, _kvbuf_make_purgeable, _kvbuf_new, 
+                       _kvbuf_new_zone, _kvbuf_next_dict, _kvbuf_next_key, _kvbuf_next_val, 
+                       _kvbuf_next_val_len, _kvbuf_query, _kvbuf_query_key_int, _kvbuf_query_key_uint, 
+                       _kvbuf_query_key_val, _kvbuf_reset, _lookup_close_connections, 
+                       _mbr_check_membership, _mbr_check_membership_by_id, _mbr_check_membership_ext, 
+                       _mbr_check_membership_refresh, _mbr_check_service_membership, 
+                       _mbr_close_connections, _mbr_gid_to_uuid, _mbr_group_name_to_uuid, 
+                       _mbr_identifier_to_uuid, _mbr_identifier_translate, _mbr_reset_cache, 
+                       _mbr_set_identifier_ttl, _mbr_sid_to_string, _mbr_sid_to_uuid, 
+                       _mbr_string_to_sid, _mbr_string_to_uuid, _mbr_uid_to_uuid, 
+                       _mbr_user_name_to_uuid, _mbr_uuid_to_id, _mbr_uuid_to_sid, 
+                       _mbr_uuid_to_sid_type, _mbr_uuid_to_string, _ntohl, _ntohs, 
+                       _pmap_getmaps, _pmap_getport, _pmap_rmtcall, _pmap_set, _pmap_unset, 
+                       _prdb_end, _prdb_get, _prdb_getbyname, _prdb_set, _rcmd, _rcmd_af, 
+                       _res_init, _res_query, _res_search, _rpc_createerr, _rresvport, 
+                       _rresvport_af, _ruserok, _setdomainname, _setfsent, _setgrent, 
+                       _setgroupent, _sethostent, _setnetent, _setnetgrent, _setpassent, 
+                       _setprotoent, _setpwent, _setrpcent, _setservent, _si_addrinfo, 
+                       _si_addrinfo_list, _si_addrinfo_list_from_hostent, _si_addrinfo_v4, 
+                       _si_addrinfo_v4_mapped, _si_addrinfo_v6, _si_alias_all, _si_alias_byname, 
+                       _si_async_call, _si_async_cancel, _si_async_handle_reply, 
+                       _si_destination_compare, _si_destination_compare_no_dependencies, 
+                       _si_fs_all, _si_fs_byfile, _si_fs_byspec, _si_group_all, _si_group_bygid, 
+                       _si_group_byname, _si_group_byuuid, _si_grouplist, _si_host_all, 
+                       _si_host_byaddr, _si_host_byname, _si_in_netgroup, _si_ipnode_byname, 
+                       _si_item_call, _si_item_is_valid, _si_item_match, _si_item_release, 
+                       _si_item_retain, _si_list_add, _si_list_call, _si_list_concat, 
+                       _si_list_next, _si_list_release, _si_list_reset, _si_list_retain, 
+                       _si_mac_all, _si_mac_bymac, _si_mac_byname, _si_module_allows_caching, 
+                       _si_module_name, _si_module_release, _si_module_retain, _si_module_vers, 
+                       _si_module_with_name, _si_nameinfo, _si_netgroup_byname, _si_network_all, 
+                       _si_network_byaddr, _si_network_byname, _si_protocol_all, 
+                       _si_protocol_byname, _si_protocol_bynumber, _si_rpc_all, _si_rpc_byname, 
+                       _si_rpc_bynumber, _si_search, _si_search_module_set_flags, 
+                       _si_service_all, _si_service_byname, _si_service_byport, _si_set_nat64_v4_requires_synthesis, 
+                       _si_set_nat64_v4_synthesize, _si_srv_byname, _si_standardize_mac_address, 
+                       _si_user_all, _si_user_byname, _si_user_byuid, _si_user_byuuid, 
+                       _si_wants_addrinfo, _svc_fdset, _svc_getreq, _svc_getreqset, 
+                       _svc_register, _svc_run, _svc_sendreply, _svc_unregister, 
+                       _svcerr_auth, _svcerr_decode, _svcerr_noproc, _svcerr_noprog, 
+                       _svcerr_progvers, _svcerr_systemerr, _svcerr_weakauth, _svcfd_create, 
+                       _svcraw_create, _svctcp_create, _svcudp_bufcreate, _svcudp_create, 
+                       _user_from_uid, _xdr_array, _xdr_authunix_parms, _xdr_bool, 
+                       _xdr_bytes, _xdr_callhdr, _xdr_callmsg, _xdr_char, _xdr_des_block, 
+                       _xdr_domainname, _xdr_double, _xdr_enum, _xdr_float, _xdr_free, 
+                       _xdr_hyper, _xdr_int, _xdr_int16_t, _xdr_int32_t, _xdr_int64_t, 
+                       _xdr_keydat, _xdr_long, _xdr_longlong_t, _xdr_mapname, _xdr_netobj, 
+                       _xdr_opaque, _xdr_peername, _xdr_pmap, _xdr_pmaplist, _xdr_pointer, 
+                       _xdr_reference, _xdr_replymsg, _xdr_rmtcall_args, _xdr_rmtcallres, 
+                       _xdr_short, _xdr_string, _xdr_u_char, _xdr_u_hyper, _xdr_u_int, 
+                       _xdr_u_int16_t, _xdr_u_int32_t, _xdr_u_int64_t, _xdr_u_long, 
+                       _xdr_u_longlong_t, _xdr_u_short, _xdr_union, _xdr_valdat, 
+                       _xdr_vector, _xdr_void, _xdr_wrapstring, _xdr_x_passwd, _xdr_ypbind_binding, 
+                       _xdr_ypbind_resp, _xdr_ypbind_resptype, _xdr_ypbind_setdom, 
+                       _xdr_ypmaplist, _xdr_yppasswd, _xdr_ypreq_key, _xdr_ypreq_nokey, 
+                       _xdr_ypresp_all, _xdr_ypresp_all_seq, _xdr_ypresp_key_val, 
+                       _xdr_ypresp_maplist, _xdr_ypresp_master, _xdr_ypresp_order, 
+                       _xdr_ypresp_val, _xdr_ypstat, _xdrmem_create, _xdrrec_create, 
+                       _xdrrec_endofrecord, _xdrrec_eof, _xdrrec_skiprecord, _xdrstdio_create, 
+                       _xprt_register, _xprt_unregister, _yp_all, _yp_bind, _yp_first, 
+                       _yp_get_default_domain, _yp_maplist, _yp_master, _yp_match, 
+                       _yp_next, _yp_order, _yp_unbind, _yperr_string, _ypprot_err ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           6D1DB971-27A7-3DBC-A7FF-1D25A88E5282
+  - target:          x86_64-maccatalyst
+    value:           6D1DB971-27A7-3DBC-A7FF-1D25A88E5282
+  - target:          arm64-macos
+    value:           B529197C-5FB5-3ABB-915F-9EB576658F0F
+  - target:          arm64-maccatalyst
+    value:           B529197C-5FB5-3ABB-915F-9EB576658F0F
+  - target:          arm64e-macos
+    value:           66D9DC04-E3C0-329C-B4CA-8C6E2CCA7FD3
+  - target:          arm64e-maccatalyst
+    value:           66D9DC04-E3C0-329C-B4CA-8C6E2CCA7FD3
+install-name:    '/usr/lib/system/libsystem_kernel.dylib'
+current-version: 8792.41.7
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
+    symbols:         [ '_fstat$INODE64', '_fstatat$INODE64', '_fstatfs$INODE64', 
+                       '_getfsstat$INODE64', _i386_get_ldt, _i386_set_ldt, '_lstat$INODE64', 
+                       '_pselect$1050', '_select$1050', '_stat$INODE64', '_statfs$INODE64' ]
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _NDR_record, _____sigwait_nocancel, ____kernelVersionNumber, 
+                       ____kernelVersionString, ___abort_with_payload, ___accept, 
+                       ___accept_nocancel, ___access_extended, ___aio_suspend_nocancel, 
+                       ___bind, ___bsdthread_create, ___bsdthread_ctl, ___bsdthread_register, 
+                       ___bsdthread_terminate, ___carbon_delete, ___channel_get_info, 
+                       ___channel_get_opt, ___channel_open, ___channel_set_opt, ___channel_sync, 
+                       ___chmod, ___chmod_extended, ___close_nocancel, ___coalition, 
+                       ___coalition_info, ___coalition_ledger, ___commpage_gettimeofday, 
+                       ___connect, ___connect_nocancel, ___copyfile, ___csrctl, ___darwin_check_fd_set_overflow, 
+                       ___debug_syscall_reject, ___debug_syscall_reject_config, ___delete, 
+                       ___disable_threadsignal, ___error, ___execve, ___exit, ___fchmod, 
+                       ___fchmod_extended, ___fcntl, ___fcntl_nocancel, ___fork, 
+                       ___fs_snapshot, ___fstat64_extended, ___fstat_extended, ___fsync_nocancel, 
+                       ___get_remove_counter, ___getattrlist, ___getdirentries64, 
+                       ___gethostuuid, ___getlogin, ___getpeername, ___getpid, ___getrlimit, 
+                       ___getsgroups, ___getsockname, ___gettid, ___gettimeofday, 
+                       ___getwgroups, ___guarded_open_dprotected_np, ___guarded_open_np, 
+                       ___identitysvc, ___inc_remove_counter, ___initgroups, ___ioctl, 
+                       ___iopolicysys, ___kdebug_trace, ___kdebug_trace64, ___kdebug_trace_string, 
+                       ___kdebug_typefilter, ___kill, ___kqueue_workloop_ctl, ___lchown, 
+                       ___libkernel_init, ___libkernel_init_after_boot_tasks, ___libkernel_init_late, 
+                       ___libkernel_platform_init, ___libkernel_voucher_init, ___listen, 
+                       ___log_data, ___lseek, ___lstat64_extended, ___lstat_extended, 
+                       ___mac_execve, ___mac_get_fd, ___mac_get_file, ___mac_get_link, 
+                       ___mac_get_mount, ___mac_get_pid, ___mac_get_proc, ___mac_getfsstat, 
+                       ___mac_mount, ___mac_set_fd, ___mac_set_file, ___mac_set_link, 
+                       ___mac_set_proc, ___mac_syscall, ___mach_bridge_remote_time, 
+                       ___mach_eventlink_signal, ___mach_eventlink_signal_wait_until, 
+                       ___mach_eventlink_wait_until, ___map_with_linking_np, ___memorystatus_available_memory, 
+                       ___microstackshot, ___mkdir_extended, ___mkfifo_extended, 
+                       ___mmap, ___mprotect, ___msgctl, ___msgrcv_nocancel, ___msgsnd_nocancel, 
+                       ___msgsys, ___msync, ___msync_nocancel, ___munmap, ___nexus_create, 
+                       ___nexus_deregister, ___nexus_destroy, ___nexus_get_opt, ___nexus_open, 
+                       ___nexus_register, ___nexus_set_opt, ___open, ___open_dprotected_np, 
+                       ___open_extended, ___open_nocancel, ___openat, ___openat_dprotected_np, 
+                       ___openat_nocancel, ___os_nexus_flow_add, ___os_nexus_flow_del, 
+                       ___os_nexus_get_llink_info, ___os_nexus_ifattach, ___os_nexus_ifdetach, 
+                       ___persona, ___pipe, ___poll_nocancel, ___posix_spawn, ___pread_nocancel, 
+                       ___preadv_nocancel, ___proc_info, ___proc_info_extended_id, 
+                       ___process_policy, ___pselect, ___pselect_nocancel, ___psynch_cvbroad, 
+                       ___psynch_cvclrprepost, ___psynch_cvsignal, ___psynch_cvwait, 
+                       ___psynch_mutexdrop, ___psynch_mutexwait, ___psynch_rw_downgrade, 
+                       ___psynch_rw_longrdlock, ___psynch_rw_rdlock, ___psynch_rw_unlock, 
+                       ___psynch_rw_unlock2, ___psynch_rw_upgrade, ___psynch_rw_wrlock, 
+                       ___psynch_rw_yieldwrlock, ___pthread_canceled, ___pthread_chdir, 
+                       ___pthread_fchdir, ___pthread_kill, ___pthread_markcancel, 
+                       ___pthread_sigmask, ___ptrace, ___pwrite_nocancel, ___pwritev_nocancel, 
+                       ___read_nocancel, ___readv_nocancel, ___reboot, ___record_system_event, 
+                       ___recvfrom, ___recvfrom_nocancel, ___recvmsg, ___recvmsg_nocancel, 
+                       ___rename, ___renameat, ___renameatx_np, ___rmdir, ___sandbox_me, 
+                       ___sandbox_mm, ___sandbox_ms, ___sandbox_msp, ___select, ___select_nocancel, 
+                       ___sem_open, ___sem_wait_nocancel, ___semctl, ___semsys, ___semwait_signal, 
+                       ___semwait_signal_nocancel, ___sendmsg, ___sendmsg_nocancel, 
+                       ___sendto, ___sendto_nocancel, ___setattrlist, ___setlogin, 
+                       ___setpriority, ___setregid, ___setreuid, ___setrlimit, ___setsgroups, 
+                       ___settid, ___settid_with_pid, ___settimeofday, ___setwgroups, 
+                       ___sfi_ctl, ___sfi_pidctl, ___shared_region_check_np, ___shared_region_map_and_slide_2_np, 
+                       ___shm_open, ___shmctl, ___shmsys, ___sigaction, ___sigaltstack, 
+                       ___sigreturn, ___sigsuspend, ___sigsuspend_nocancel, ___sigwait, 
+                       ___socketpair, ___stack_snapshot_with_config, ___stat64_extended, 
+                       ___stat_extended, ___syscall, ___syscall_logger, ___sysctl, 
+                       ___sysctlbyname, ___telemetry, ___terminate_with_payload, 
+                       ___thread_selfid, ___thread_selfusage, ___ulock_wait, ___ulock_wait2, 
+                       ___ulock_wake, ___umask_extended, ___unlink, ___unlinkat, 
+                       ___vfork, ___wait4, ___wait4_nocancel, ___waitid_nocancel, 
+                       ___work_interval_ctl, ___workq_kernreturn, ___workq_open, 
+                       ___write_nocancel, ___writev_nocancel, __cpu_capabilities, 
+                       __cpu_has_altivec, __exit, __get_cpu_capabilities, __getprivatesystemidentifier, 
+                       __host_page_size, __init_cpu_capabilities, __kernelrpc_host_create_mach_voucher, 
+                       __kernelrpc_mach_port_allocate, __kernelrpc_mach_port_allocate_full, 
+                       __kernelrpc_mach_port_allocate_name, __kernelrpc_mach_port_allocate_qos, 
+                       __kernelrpc_mach_port_allocate_trap, __kernelrpc_mach_port_assert_attributes, 
+                       __kernelrpc_mach_port_construct, __kernelrpc_mach_port_construct_trap, 
+                       __kernelrpc_mach_port_deallocate, __kernelrpc_mach_port_deallocate_trap, 
+                       __kernelrpc_mach_port_destroy, __kernelrpc_mach_port_destruct, 
+                       __kernelrpc_mach_port_destruct_trap, __kernelrpc_mach_port_dnrequest_info, 
+                       __kernelrpc_mach_port_extract_member, __kernelrpc_mach_port_extract_member_trap, 
+                       __kernelrpc_mach_port_extract_right, __kernelrpc_mach_port_get_attributes, 
+                       __kernelrpc_mach_port_get_attributes_trap, __kernelrpc_mach_port_get_context, 
+                       __kernelrpc_mach_port_get_refs, __kernelrpc_mach_port_get_service_port_info, 
+                       __kernelrpc_mach_port_get_set_status, __kernelrpc_mach_port_get_srights, 
+                       __kernelrpc_mach_port_guard, __kernelrpc_mach_port_guard_trap, 
+                       __kernelrpc_mach_port_guard_with_flags, __kernelrpc_mach_port_insert_member, 
+                       __kernelrpc_mach_port_insert_member_trap, __kernelrpc_mach_port_insert_right, 
+                       __kernelrpc_mach_port_insert_right_trap, __kernelrpc_mach_port_is_connection_for_service, 
+                       __kernelrpc_mach_port_kernel_object, __kernelrpc_mach_port_kobject, 
+                       __kernelrpc_mach_port_kobject_description, __kernelrpc_mach_port_mod_refs, 
+                       __kernelrpc_mach_port_mod_refs_trap, __kernelrpc_mach_port_move_member, 
+                       __kernelrpc_mach_port_move_member_trap, __kernelrpc_mach_port_names, 
+                       __kernelrpc_mach_port_peek, __kernelrpc_mach_port_rename, 
+                       __kernelrpc_mach_port_request_notification, __kernelrpc_mach_port_request_notification_trap, 
+                       __kernelrpc_mach_port_set_attributes, __kernelrpc_mach_port_set_context, 
+                       __kernelrpc_mach_port_set_mscount, __kernelrpc_mach_port_set_seqno, 
+                       __kernelrpc_mach_port_space_basic_info, __kernelrpc_mach_port_space_info, 
+                       __kernelrpc_mach_port_special_reply_port_reset_link, __kernelrpc_mach_port_swap_guard, 
+                       __kernelrpc_mach_port_type, __kernelrpc_mach_port_type_trap, 
+                       __kernelrpc_mach_port_unguard, __kernelrpc_mach_port_unguard_trap, 
+                       __kernelrpc_mach_task_is_self, __kernelrpc_mach_vm_allocate, 
+                       __kernelrpc_mach_vm_allocate_trap, __kernelrpc_mach_vm_deallocate, 
+                       __kernelrpc_mach_vm_deallocate_trap, __kernelrpc_mach_vm_map, 
+                       __kernelrpc_mach_vm_map_trap, __kernelrpc_mach_vm_protect, 
+                       __kernelrpc_mach_vm_protect_trap, __kernelrpc_mach_vm_purgable_control, 
+                       __kernelrpc_mach_vm_purgable_control_trap, __kernelrpc_mach_vm_read, 
+                       __kernelrpc_mach_vm_remap, __kernelrpc_mach_vm_remap_new, 
+                       __kernelrpc_mach_voucher_extract_attr_recipe, __kernelrpc_task_set_port_space, 
+                       __kernelrpc_thread_policy, __kernelrpc_thread_policy_set, 
+                       __kernelrpc_thread_set_policy, __kernelrpc_vm_map, __kernelrpc_vm_purgable_control, 
+                       __kernelrpc_vm_read, __kernelrpc_vm_remap, __kernelrpc_vm_remap_new, 
+                       __mach_errors, __mach_fork_child, __mach_snprintf, __mach_vsnprintf, 
+                       __os_alloc_once_table, __os_xbs_chrooted, __register_gethostuuid_callback, 
+                       __thread_set_tsd_base, _abort_with_payload, _abort_with_reason, 
+                       _accept, '_accept$NOCANCEL', _access, _accessx_np, _acct, 
+                       _act_get_state, _act_set_state, _adjtime, _aio_cancel, _aio_error, 
+                       _aio_fsync, _aio_read, _aio_return, _aio_suspend, '_aio_suspend$NOCANCEL', 
+                       _aio_write, _audit, _audit_session_join, _audit_session_port, 
+                       _audit_session_self, _auditctl, _auditon, _bind, _bootstrap_port, 
+                       _cerror, _cerror_nocancel, _change_fdguard_np, _chdir, _chflags, 
+                       _chmod, _chown, _chroot, _clock_alarm, _clock_alarm_reply, 
+                       _clock_get_attributes, _clock_get_time, _clock_set_attributes, 
+                       _clock_set_time, _clock_sleep, _clock_sleep_trap, _clonefile, 
+                       _clonefileat, _close, '_close$NOCANCEL', _coalition_create, 
+                       _coalition_info_resource_usage, _coalition_info_set_efficiency, 
+                       _coalition_info_set_name, _coalition_ledger_set_logical_writes_limit, 
+                       _coalition_reap, _coalition_terminate, _connect, '_connect$NOCANCEL', 
+                       _connectx, _csops, _csops_audittoken, _csr_check, _csr_get_active_config, 
+                       _debug_control_port_for_pid, _debug_syscall_reject, _debug_syscall_reject_config, 
+                       _denap_boost_assertion_token, _disconnectx, _dup, _dup2, _errno, 
+                       _etap_trace_thread, _exc_server, _exc_server_routine, _exception_raise, 
+                       _exception_raise_state, _exception_raise_state_identity, _exchangedata, 
+                       _execve, _faccessat, _fchdir, _fchflags, _fchmod, _fchmodat, 
+                       _fchown, _fchownat, _fclonefileat, _fcntl, '_fcntl$NOCANCEL', 
+                       _fdatasync, _ffsctl, _fgetattrlist, _fgetxattr, _fhopen, _fileport_makefd, 
+                       _fileport_makeport, _flistxattr, _flock, _fmount, _fpathconf, 
+                       _freadlink, _fremovexattr, _fs_snapshot_create, _fs_snapshot_delete, 
+                       _fs_snapshot_list, _fs_snapshot_mount, _fs_snapshot_rename, 
+                       _fs_snapshot_revert, _fs_snapshot_root, _fsctl, _fsetattrlist, 
+                       _fsetxattr, _fsgetpath, _fsgetpath_ext, _fstat, _fstat64, 
+                       _fstatat, _fstatat64, _fstatfs, _fstatfs64, _fsync, '_fsync$NOCANCEL', 
+                       _ftruncate, _futimens, _futimes, _getattrlist, _getattrlistat, 
+                       _getattrlistbulk, _getaudit, _getaudit_addr, _getauid, _getdirentries, 
+                       _getdirentriesattr, _getdtablesize, _getegid, _getentropy, 
+                       _geteuid, _getfh, _getfsstat, _getfsstat64, _getgid, _getgroups, 
+                       _gethostuuid, _getiopolicy_np, _getitimer, _getpeername, _getpgid, 
+                       _getpgrp, _getpid, _getppid, _getpriority, _getrlimit, _getrusage, 
+                       _getsgroups_np, _getsid, _getsockname, _getsockopt, _getuid, 
+                       _getwgroups_np, _getxattr, _grab_pgo_data, _graftdmg, _guarded_close_np, 
+                       _guarded_kqueue_np, _guarded_open_dprotected_np, _guarded_open_np, 
+                       _guarded_pwrite_np, _guarded_write_np, _guarded_writev_np, 
+                       _host_check_multiuser_mode, _host_create_mach_voucher, _host_create_mach_voucher_trap, 
+                       _host_default_memory_manager, _host_get_UNDServer, _host_get_atm_diagnostic_flag, 
+                       _host_get_boot_info, _host_get_clock_control, _host_get_clock_service, 
+                       _host_get_exception_ports, _host_get_io_main, _host_get_io_master, 
+                       _host_get_multiuser_config_flags, _host_get_special_port, 
+                       _host_info, _host_kernel_version, _host_lockgroup_info, _host_page_size, 
+                       _host_priv_statistics, _host_processor_info, _host_processor_set_priv, 
+                       _host_processor_sets, _host_processors, _host_reboot, _host_register_mach_voucher_attr_manager, 
+                       _host_register_well_known_mach_voucher_attr_manager, _host_request_notification, 
+                       _host_security_create_task_token, _host_security_set_task_token, 
+                       _host_self, _host_self_trap, _host_set_UNDServer, _host_set_atm_diagnostic_flag, 
+                       _host_set_exception_ports, _host_set_multiuser_config_flags, 
+                       _host_set_special_port, _host_statistics, _host_statistics64, 
+                       _host_swap_exception_ports, _host_virtual_physical_table_info, 
+                       _important_boost_assertion_token, _internal_catch_exc_subsystem, 
+                       _ioctl, _issetugid, _kas_info, _kdebug_is_enabled, _kdebug_signpost, 
+                       _kdebug_signpost_end, _kdebug_signpost_start, _kdebug_timestamp, 
+                       _kdebug_timestamp_from_absolute, _kdebug_timestamp_from_continuous, 
+                       _kdebug_trace, _kdebug_trace_string, _kdebug_typefilter, _kdebug_using_continuous_time, 
+                       _kevent, _kevent64, _kevent_id, _kevent_qos, _kext_request, 
+                       _kill, _kmod_control, _kmod_create, _kmod_destroy, _kmod_get_info, 
+                       _kpersona_alloc, _kpersona_dealloc, _kpersona_find, _kpersona_find_by_type, 
+                       _kpersona_get, _kpersona_getpath, _kpersona_info, _kpersona_palloc, 
+                       _kpersona_pidinfo, _kqueue, _lchown, _ledger, _link, _linkat, 
+                       _lio_listio, _listen, _listxattr, _lock_set_create, _lock_set_destroy, 
+                       _log_data_as_kernel, _lseek, _lstat, _lstat64, _mach_absolute_time, 
+                       _mach_approximate_time, _mach_boottime_usec, _mach_continuous_approximate_time, 
+                       _mach_continuous_time, _mach_error, _mach_error_full_diag, 
+                       _mach_error_string, _mach_error_type, _mach_eventlink_associate, 
+                       _mach_eventlink_create, _mach_eventlink_destroy, _mach_eventlink_disassociate, 
+                       _mach_eventlink_signal, _mach_eventlink_signal_wait_until, 
+                       _mach_eventlink_wait_until, _mach_generate_activity_id, _mach_get_times, 
+                       _mach_host_self, _mach_host_special_port_description, _mach_host_special_port_for_id, 
+                       _mach_init, _mach_make_memory_entry, _mach_make_memory_entry_64, 
+                       _mach_memory_entry_access_tracking, _mach_memory_entry_ownership, 
+                       _mach_memory_entry_purgable_control, _mach_memory_info, _mach_memory_object_memory_entry, 
+                       _mach_memory_object_memory_entry_64, _mach_msg, _mach_msg2_internal, 
+                       _mach_msg2_trap, _mach_msg_destroy, _mach_msg_overwrite, _mach_msg_overwrite_trap, 
+                       _mach_msg_priority_encode, _mach_msg_priority_is_pthread_priority, 
+                       _mach_msg_priority_overide_qos, _mach_msg_priority_qos, _mach_msg_priority_relpri, 
+                       _mach_msg_receive, _mach_msg_send, _mach_msg_server, _mach_msg_server_importance, 
+                       _mach_msg_server_once, _mach_msg_trap, _mach_notify_dead_name, 
+                       _mach_notify_no_senders, _mach_notify_port_deleted, _mach_notify_port_destroyed, 
+                       _mach_notify_send_once, _mach_port_allocate, _mach_port_allocate_full, 
+                       _mach_port_allocate_name, _mach_port_allocate_qos, _mach_port_assert_attributes, 
+                       _mach_port_construct, _mach_port_deallocate, _mach_port_destroy, 
+                       _mach_port_destruct, _mach_port_dnrequest_info, _mach_port_extract_member, 
+                       _mach_port_extract_right, _mach_port_get_attributes, _mach_port_get_context, 
+                       _mach_port_get_refs, _mach_port_get_service_port_info, _mach_port_get_set_status, 
+                       _mach_port_get_srights, _mach_port_guard, _mach_port_guard_with_flags, 
+                       _mach_port_insert_member, _mach_port_insert_right, _mach_port_is_connection_for_service, 
+                       _mach_port_kernel_object, _mach_port_kobject, _mach_port_kobject_description, 
+                       _mach_port_mod_refs, _mach_port_move_member, _mach_port_names, 
+                       _mach_port_peek, _mach_port_rename, _mach_port_request_notification, 
+                       _mach_port_set_attributes, _mach_port_set_context, _mach_port_set_mscount, 
+                       _mach_port_set_seqno, _mach_port_space_basic_info, _mach_port_space_info, 
+                       _mach_port_swap_guard, _mach_port_type, _mach_port_unguard, 
+                       _mach_ports_lookup, _mach_ports_register, _mach_reply_port, 
+                       _mach_right_recv_construct, _mach_right_recv_destruct, _mach_right_send_create, 
+                       _mach_right_send_once_consume, _mach_right_send_once_create, 
+                       _mach_right_send_release, _mach_right_send_retain, _mach_sync_ipc_link_monitoring_start, 
+                       _mach_sync_ipc_link_monitoring_stop, _mach_task_is_self, _mach_task_self, 
+                       _mach_task_self_, _mach_task_special_port_description, _mach_task_special_port_for_id, 
+                       _mach_thread_self, _mach_thread_special_port_description, 
+                       _mach_thread_special_port_for_id, _mach_timebase_info, _mach_timebase_info_trap, 
+                       _mach_vm_allocate, _mach_vm_behavior_set, _mach_vm_copy, _mach_vm_deallocate, 
+                       _mach_vm_deferred_reclamation_buffer_init, _mach_vm_deferred_reclamation_buffer_synchronize, 
+                       _mach_vm_deferred_reclamation_buffer_update_reclaimable_bytes, 
+                       _mach_vm_inherit, _mach_vm_machine_attribute, _mach_vm_map, 
+                       _mach_vm_msync, _mach_vm_page_info, _mach_vm_page_query, _mach_vm_page_range_query, 
+                       _mach_vm_protect, _mach_vm_purgable_control, _mach_vm_read, 
+                       _mach_vm_read_list, _mach_vm_read_overwrite, _mach_vm_reclaim_is_available, 
+                       _mach_vm_reclaim_mark_free, _mach_vm_reclaim_mark_used, _mach_vm_reclaim_ringbuffer_init, 
+                       _mach_vm_reclaim_synchronize, _mach_vm_reclaim_update_kernel_accounting, 
+                       _mach_vm_region, _mach_vm_region_recurse, _mach_vm_remap, 
+                       _mach_vm_remap_new, _mach_vm_wire, _mach_vm_write, _mach_voucher_attr_command, 
+                       _mach_voucher_deallocate, _mach_voucher_debug_info, _mach_voucher_extract_all_attr_recipes, 
+                       _mach_voucher_extract_attr_content, _mach_voucher_extract_attr_recipe, 
+                       _mach_voucher_extract_attr_recipe_trap, _mach_wait_until, 
+                       _mach_zone_force_gc, _mach_zone_get_btlog_records, _mach_zone_get_zlog_zones, 
+                       _mach_zone_info, _mach_zone_info_for_largest_zone, _mach_zone_info_for_zone, 
+                       _macx_backing_store_recovery, _macx_backing_store_suspend, 
+                       _macx_swapoff, _macx_swapon, _macx_triggers, _madvise, _memorystatus_control, 
+                       _memorystatus_get_level, _mig_allocate, _mig_dealloc_reply_port, 
+                       _mig_dealloc_special_reply_port, _mig_deallocate, _mig_get_reply_port, 
+                       _mig_get_special_reply_port, _mig_put_reply_port, _mig_reply_setup, 
+                       _mig_strncpy, _mig_strncpy_zerofill, _mincore, _minherit, 
+                       _mk_timer_arm, _mk_timer_arm_leeway, _mk_timer_cancel, _mk_timer_create, 
+                       _mk_timer_destroy, _mkdir, _mkdirat, _mkfifo, _mkfifoat, _mknod, 
+                       _mknodat, _mlock, _mlockall, _mmap, _mount, _mprotect, _mremap_encrypted, 
+                       _msg_receive, _msg_rpc, _msg_send, _msgctl, _msgget, _msgrcv, 
+                       '_msgrcv$NOCANCEL', _msgsnd, '_msgsnd$NOCANCEL', _msgsys, 
+                       _msync, '_msync$NOCANCEL', _munlock, _munlockall, _munmap, 
+                       _necp_client_action, _necp_match_policy, _necp_open, _necp_session_action, 
+                       _necp_session_open, _net_qos_guideline, _netagent_trigger, 
+                       _netname_check_in, _netname_check_out, _netname_look_up, _netname_version, 
+                       _nfsclnt, _nfssvc, _non_boost_assertion_token, _normal_boost_assertion_token, 
+                       _ntp_adjtime, _ntp_gettime, _objc_bp_assist_cfg_np, _open, 
+                       '_open$NOCANCEL', _open_dprotected_np, _openat, '_openat$NOCANCEL', 
+                       _openat_authenticated_np, _openat_dprotected_np, _openbyid_np, 
+                       _os_buflet_get_data_address, _os_buflet_get_data_length, _os_buflet_get_data_limit, 
+                       _os_buflet_get_data_offset, _os_buflet_get_gro_len, _os_buflet_get_next_buf, 
+                       _os_buflet_get_object_address, _os_buflet_get_object_limit, 
+                       _os_buflet_get_object_offset, _os_buflet_set_data_length, 
+                       _os_buflet_set_data_offset, _os_channel_advance_slot, _os_channel_attr_clone, 
+                       _os_channel_attr_create, _os_channel_attr_destroy, _os_channel_attr_get, 
+                       _os_channel_attr_get_key, _os_channel_attr_set, _os_channel_attr_set_key, 
+                       _os_channel_available_slot_count, _os_channel_buflet_alloc, 
+                       _os_channel_buflet_free, _os_channel_configure_interface_advisory, 
+                       _os_channel_create, _os_channel_create_extended, _os_channel_destroy, 
+                       _os_channel_event_free, _os_channel_event_get_event_data, 
+                       _os_channel_event_get_next_event, _os_channel_flow_admissible, 
+                       _os_channel_get_advisory_region, _os_channel_get_fd, _os_channel_get_interface_advisory, 
+                       _os_channel_get_next_event_handle, _os_channel_get_next_slot, 
+                       _os_channel_get_stats_region, _os_channel_is_defunct, _os_channel_packet_alloc, 
+                       _os_channel_packet_free, _os_channel_packet_pool_purge, _os_channel_pending, 
+                       _os_channel_read_attr, _os_channel_read_nexus_extension_info, 
+                       _os_channel_ring_id, _os_channel_ring_notify_time, _os_channel_ring_sync_time, 
+                       _os_channel_rx_ring, _os_channel_set_slot_properties, _os_channel_slot_attach_packet, 
+                       _os_channel_slot_detach_packet, _os_channel_slot_get_packet, 
+                       _os_channel_sync, _os_channel_tx_ring, _os_channel_write_attr, 
+                       _os_copy_and_inet_checksum, _os_cpu_copy_in_cksum, _os_cpu_in_cksum, 
+                       _os_cpu_in_cksum_mbuf, _os_fault_with_payload, _os_inet_checksum, 
+                       _os_nexus_attr_clone, _os_nexus_attr_create, _os_nexus_attr_destroy, 
+                       _os_nexus_attr_get, _os_nexus_attr_set, _os_nexus_controller_add_traffic_rule, 
+                       _os_nexus_controller_alloc_provider_instance, _os_nexus_controller_bind_provider_instance, 
+                       _os_nexus_controller_create, _os_nexus_controller_deregister_provider, 
+                       _os_nexus_controller_destroy, _os_nexus_controller_free_provider_instance, 
+                       _os_nexus_controller_get_fd, _os_nexus_controller_iterate_traffic_rules, 
+                       _os_nexus_controller_read_provider_attr, _os_nexus_controller_register_provider, 
+                       _os_nexus_controller_remove_traffic_rule, _os_nexus_controller_unbind_provider_instance, 
+                       _os_packet_add_buflet, _os_packet_clear_flow_uuid, _os_packet_decrement_use_count, 
+                       _os_packet_finalize, _os_packet_get_aggregation_type, _os_packet_get_buflet_count, 
+                       _os_packet_get_compression_generation_count, _os_packet_get_data_length, 
+                       _os_packet_get_expire_time, _os_packet_get_expiry_action, 
+                       _os_packet_get_flow_uuid, _os_packet_get_group_end, _os_packet_get_group_start, 
+                       _os_packet_get_headroom, _os_packet_get_inet_checksum, _os_packet_get_keep_alive, 
+                       _os_packet_get_link_broadcast, _os_packet_get_link_ethfcs, 
+                       _os_packet_get_link_header_length, _os_packet_get_link_multicast, 
+                       _os_packet_get_next_buflet, _os_packet_get_packetid, _os_packet_get_segment_count, 
+                       _os_packet_get_service_class, _os_packet_get_token, _os_packet_get_trace_id, 
+                       _os_packet_get_traffic_class, _os_packet_get_transport_retransmit, 
+                       _os_packet_get_transport_traffic_background, _os_packet_get_transport_traffic_realtime, 
+                       _os_packet_get_truncated, _os_packet_get_vlan_id, _os_packet_get_vlan_priority, 
+                       _os_packet_get_vlan_tag, _os_packet_get_wake_flag, _os_packet_increment_use_count, 
+                       _os_packet_set_app_metadata, _os_packet_set_compression_generation_count, 
+                       _os_packet_set_expire_time, _os_packet_set_expiry_action, 
+                       _os_packet_set_flow_uuid, _os_packet_set_group_end, _os_packet_set_group_start, 
+                       _os_packet_set_headroom, _os_packet_set_inet_checksum, _os_packet_set_keep_alive, 
+                       _os_packet_set_link_broadcast, _os_packet_set_link_ethfcs, 
+                       _os_packet_set_link_header_length, _os_packet_set_link_multicast, 
+                       _os_packet_set_packetid, _os_packet_set_protocol_segment_size, 
+                       _os_packet_set_service_class, _os_packet_set_token, _os_packet_set_trace_id, 
+                       _os_packet_set_traffic_class, _os_packet_set_transport_last_packet, 
+                       _os_packet_set_transport_retransmit, _os_packet_set_transport_traffic_background, 
+                       _os_packet_set_transport_traffic_realtime, _os_packet_set_tso_flags, 
+                       _os_packet_set_vlan_tag, _os_packet_trace_event, _os_proc_available_memory, 
+                       _panic, _panic_init, _pathconf, _peeloff, _pid_for_task, _pid_hibernate, 
+                       _pid_resume, _pid_shutdown_networking, _pid_shutdown_sockets, 
+                       _pid_suspend, _pipe, _pivot_root, _pkt_subtype_assert_fail, 
+                       _pkt_type_assert_fail, _poll, '_poll$NOCANCEL', _port_obj_init, 
+                       _port_obj_table, _port_obj_table_size, _posix_madvise, _posix_spawn, 
+                       _posix_spawn_file_actions_add_fileportdup2_np, _posix_spawn_file_actions_addchdir_np, 
+                       _posix_spawn_file_actions_addclose, _posix_spawn_file_actions_adddup2, 
+                       _posix_spawn_file_actions_addfchdir_np, _posix_spawn_file_actions_addinherit_np, 
+                       _posix_spawn_file_actions_addopen, _posix_spawn_file_actions_destroy, 
+                       _posix_spawn_file_actions_init, _posix_spawnattr_destroy, 
+                       _posix_spawnattr_disable_ptr_auth_a_keys_np, _posix_spawnattr_get_darwin_role_np, 
+                       _posix_spawnattr_get_qos_clamp_np, _posix_spawnattr_getarchpref_np, 
+                       _posix_spawnattr_getbinpref_np, _posix_spawnattr_getcpumonitor, 
+                       _posix_spawnattr_getflags, _posix_spawnattr_getmacpolicyinfo_np, 
+                       _posix_spawnattr_getpcontrol_np, _posix_spawnattr_getpgroup, 
+                       _posix_spawnattr_getprocesstype_np, _posix_spawnattr_getsigdefault, 
+                       _posix_spawnattr_getsigmask, _posix_spawnattr_init, _posix_spawnattr_set_alt_rosetta_np, 
+                       _posix_spawnattr_set_crash_behavior_deadline_np, _posix_spawnattr_set_crash_behavior_np, 
+                       _posix_spawnattr_set_csm_np, _posix_spawnattr_set_darwin_role_np, 
+                       _posix_spawnattr_set_filedesclimit_ext, _posix_spawnattr_set_gid_np, 
+                       _posix_spawnattr_set_groups_np, _posix_spawnattr_set_importancewatch_port_np, 
+                       _posix_spawnattr_set_jetsam_ttr_np, _posix_spawnattr_set_launch_type_np, 
+                       _posix_spawnattr_set_login_np, _posix_spawnattr_set_max_addr_np, 
+                       _posix_spawnattr_set_persona_gid_np, _posix_spawnattr_set_persona_groups_np, 
+                       _posix_spawnattr_set_persona_np, _posix_spawnattr_set_persona_uid_np, 
+                       _posix_spawnattr_set_platform_np, _posix_spawnattr_set_portlimits_ext, 
+                       _posix_spawnattr_set_ptrauth_task_port_np, _posix_spawnattr_set_qos_clamp_np, 
+                       _posix_spawnattr_set_registered_ports_np, _posix_spawnattr_set_subsystem_root_path_np, 
+                       _posix_spawnattr_set_threadlimit_ext, _posix_spawnattr_set_uid_np, 
+                       _posix_spawnattr_setarchpref_np, _posix_spawnattr_setauditsessionport_np, 
+                       _posix_spawnattr_setbinpref_np, _posix_spawnattr_setcoalition_np, 
+                       _posix_spawnattr_setcpumonitor, _posix_spawnattr_setcpumonitor_default, 
+                       _posix_spawnattr_setexceptionports_np, _posix_spawnattr_setflags, 
+                       _posix_spawnattr_setjetsam_ext, _posix_spawnattr_setmacpolicyinfo_np, 
+                       _posix_spawnattr_setnosmt_np, _posix_spawnattr_setpcontrol_np, 
+                       _posix_spawnattr_setpgroup, _posix_spawnattr_setprocesstype_np, 
+                       _posix_spawnattr_setsigdefault, _posix_spawnattr_setsigmask, 
+                       _posix_spawnattr_setspecialport_np, _pread, '_pread$NOCANCEL', 
+                       _preadv, '_preadv$NOCANCEL', _proc_clear_cpulimits, _proc_clear_delayidlesleep, 
+                       _proc_clear_dirty, _proc_clear_vmpressure, _proc_current_thread_schedinfo, 
+                       _proc_denap_assertion_begin_with_msg, _proc_denap_assertion_complete, 
+                       _proc_disable_apptype, _proc_disable_cpumon, _proc_disable_wakemon, 
+                       _proc_donate_importance_boost, _proc_enable_apptype, _proc_get_cpumon_params, 
+                       _proc_get_dirty, _proc_get_wakemon_params, _proc_importance_assertion_begin_with_msg, 
+                       _proc_importance_assertion_complete, _proc_kmsgbuf, _proc_libversion, 
+                       _proc_list_dynkqueueids, _proc_list_uptrs, _proc_listallpids, 
+                       _proc_listchildpids, _proc_listcoalitions, _proc_listpgrppids, 
+                       _proc_listpids, _proc_listpidspath, _proc_name, _proc_pid_rusage, 
+                       _proc_piddynkqueueinfo, _proc_pidfdinfo, _proc_pidfileportinfo, 
+                       _proc_pidinfo, _proc_pidoriginatorinfo, _proc_pidpath, _proc_pidpath_audittoken, 
+                       _proc_regionfilename, _proc_reset_footprint_interval, _proc_resume_cpumon, 
+                       _proc_rlimit_control, _proc_set_cpumon_defaults, _proc_set_cpumon_params, 
+                       _proc_set_cpumon_params_fatal, _proc_set_csm, _proc_set_delayidlesleep, 
+                       _proc_set_dirty, _proc_set_no_smt, _proc_set_owner_vmpressure, 
+                       _proc_set_wakemon_defaults, _proc_set_wakemon_params, _proc_setcpu_percentage, 
+                       _proc_setpcontrol, _proc_setthread_cpupercent, _proc_setthread_csm, 
+                       _proc_setthread_no_smt, _proc_suppress, _proc_terminate, _proc_terminate_all_rsr, 
+                       _proc_trace_log, _proc_track_dirty, _proc_udata_info, _proc_uuid_policy, 
+                       _processor_assign, _processor_control, _processor_exit, _processor_get_assignment, 
+                       _processor_info, _processor_set_create, _processor_set_default, 
+                       _processor_set_destroy, _processor_set_info, _processor_set_max_priority, 
+                       _processor_set_policy_control, _processor_set_policy_disable, 
+                       _processor_set_policy_enable, _processor_set_stack_usage, 
+                       _processor_set_statistics, _processor_set_tasks, _processor_set_tasks_with_flavor, 
+                       _processor_set_threads, _processor_start, _pselect, '_pselect$DARWIN_EXTSN', 
+                       '_pselect$DARWIN_EXTSN$NOCANCEL', '_pselect$NOCANCEL', _pthread_getugid_np, 
+                       _pthread_setugid_np, _ptrace, _pwrite, '_pwrite$NOCANCEL', 
+                       _pwritev, '_pwritev$NOCANCEL', _quota, _quotactl, _read, '_read$NOCANCEL', 
+                       _readlink, _readlinkat, _readv, '_readv$NOCANCEL', _reboot, 
+                       _reboot_np, _record_system_event_as_kernel, _recvfrom, '_recvfrom$NOCANCEL', 
+                       _recvmsg, '_recvmsg$NOCANCEL', _recvmsg_x, _register_uexc_handler, 
+                       _removexattr, _rename, _rename_ext, _renameat, _renameatx_np, 
+                       _renamex_np, _revoke, _rmdir, _searchfs, _select, '_select$DARWIN_EXTSN', 
+                       '_select$DARWIN_EXTSN$NOCANCEL', '_select$NOCANCEL', _sem_close, 
+                       _sem_destroy, _sem_getvalue, _sem_init, _sem_open, _sem_post, 
+                       _sem_trywait, _sem_unlink, _sem_wait, '_sem_wait$NOCANCEL', 
+                       _semaphore_create, _semaphore_destroy, _semaphore_signal, 
+                       _semaphore_signal_all, _semaphore_signal_all_trap, _semaphore_signal_thread, 
+                       _semaphore_signal_thread_trap, _semaphore_signal_trap, _semaphore_timedwait, 
+                       _semaphore_timedwait_signal, _semaphore_timedwait_signal_trap, 
+                       _semaphore_timedwait_trap, _semaphore_wait, _semaphore_wait_signal, 
+                       _semaphore_wait_signal_trap, _semaphore_wait_trap, _semctl, 
+                       _semget, _semop, _semsys, _sendfile, _sendmsg, '_sendmsg$NOCANCEL', 
+                       _sendmsg_x, _sendto, '_sendto$NOCANCEL', _setattrlist, _setattrlistat, 
+                       _setaudit, _setaudit_addr, _setauid, _setegid, _seteuid, _setgid, 
+                       _setgroups, _setiopolicy_np, _setitimer, _setpgid, _setpriority, 
+                       _setprivexec, _setquota, _setregid, _setreuid, _setrlimit, 
+                       _setsgroups_np, _setsid, _setsockopt, _setuid, _setwgroups_np, 
+                       _setxattr, _sfi_get_class_offtime, _sfi_process_get_flags, 
+                       _sfi_process_set_flags, _sfi_set_class_offtime, _shm_open, 
+                       _shm_unlink, _shmat, _shmctl, _shmdt, _shmget, _shmsys, _shutdown, 
+                       _sigpending, _sigprocmask, _sigsuspend, '_sigsuspend$NOCANCEL', 
+                       _socket, _socket_delegate, _socketpair, _stackshot_capture_with_config, 
+                       _stackshot_config_create, _stackshot_config_dealloc, _stackshot_config_dealloc_buffer, 
+                       _stackshot_config_get_stackshot_buffer, _stackshot_config_get_stackshot_size, 
+                       _stackshot_config_set_delta_timestamp, _stackshot_config_set_flags, 
+                       _stackshot_config_set_pagetable_mask, _stackshot_config_set_pid, 
+                       _stackshot_config_set_size_hint, _stat, _stat64, _statfs, 
+                       _statfs64, _swapon, _swtch, _swtch_pri, _symlink, _symlinkat, 
+                       _sync, _syscall, _syscall_thread_switch, _system_get_sfi_window, 
+                       _system_override, _system_set_sfi_window, _system_version_compat_mode, 
+                       _task_assign, _task_assign_default, _task_create, _task_create_identity_token, 
+                       _task_dyld_process_info_notify_deregister, _task_dyld_process_info_notify_get, 
+                       _task_dyld_process_info_notify_register, _task_for_pid, _task_generate_corpse, 
+                       _task_get_assignment, _task_get_dyld_image_infos, _task_get_emulation_vector, 
+                       _task_get_exc_guard_behavior, _task_get_exception_ports, _task_get_exception_ports_info, 
+                       _task_get_mach_voucher, _task_get_special_port, _task_get_state, 
+                       _task_identity_token_get_task_port, _task_info, _task_inspect, 
+                       _task_inspect_for_pid, _task_map_corpse_info, _task_map_corpse_info_64, 
+                       _task_map_kcdata_object_64, _task_name_for_pid, _task_policy, 
+                       _task_policy_get, _task_policy_set, _task_purgable_info, _task_read_for_pid, 
+                       _task_register_dyld_get_process_state, _task_register_dyld_image_infos, 
+                       _task_register_dyld_set_dyld_state, _task_register_dyld_shared_cache_image_info, 
+                       _task_restartable_ranges_register, _task_restartable_ranges_synchronize, 
+                       _task_resume, _task_resume2, _task_sample, _task_self_, _task_self_trap, 
+                       _task_set_corpse_forking_behavior, _task_set_emulation, _task_set_emulation_vector, 
+                       _task_set_exc_guard_behavior, _task_set_exception_ports, _task_set_info, 
+                       _task_set_mach_voucher, _task_set_phys_footprint_limit, _task_set_policy, 
+                       _task_set_port_space, _task_set_ras_pc, _task_set_special_port, 
+                       _task_set_state, _task_suspend, _task_suspend2, _task_swap_exception_ports, 
+                       _task_swap_mach_voucher, _task_terminate, _task_test_async_upcall_propagation, 
+                       _task_test_sync_upcall, _task_threads, _task_unregister_dyld_image_infos, 
+                       _task_zone_info, _terminate_with_payload, _terminate_with_reason, 
+                       _thread_abort, _thread_abort_safely, _thread_assign, _thread_assign_default, 
+                       _thread_convert_thread_state, _thread_create, _thread_create_running, 
+                       _thread_depress_abort, _thread_destruct_special_reply_port, 
+                       _thread_get_assignment, _thread_get_exception_ports, _thread_get_exception_ports_info, 
+                       _thread_get_mach_voucher, _thread_get_register_pointer_values, 
+                       _thread_get_special_port, _thread_get_special_reply_port, 
+                       _thread_get_state, _thread_info, _thread_policy, _thread_policy_get, 
+                       _thread_policy_set, _thread_resume, _thread_sample, _thread_self_trap, 
+                       _thread_selfcounts, _thread_set_exception_ports, _thread_set_mach_voucher, 
+                       _thread_set_policy, _thread_set_special_port, _thread_set_state, 
+                       _thread_suspend, _thread_swap_exception_ports, _thread_swap_mach_voucher, 
+                       _thread_switch, _thread_terminate, _thread_wire, _tracker_action, 
+                       _truncate, _umask, _undelete, _ungraftdmg, _unlink, _unlinkat, 
+                       _unmount, _usrctl, _utimensat, _utimes, _vfs_purge, _vm_allocate, 
+                       _vm_allocate_cpm, _vm_behavior_set, _vm_copy, _vm_deallocate, 
+                       _vm_inherit, _vm_kernel_page_mask, _vm_kernel_page_shift, 
+                       _vm_kernel_page_size, _vm_machine_attribute, _vm_map, _vm_map_page_query, 
+                       _vm_msync, _vm_page_mask, _vm_page_shift, _vm_page_size, _vm_pressure_monitor, 
+                       _vm_protect, _vm_purgable_control, _vm_read, _vm_read_list, 
+                       _vm_read_overwrite, _vm_region_64, _vm_region_recurse_64, 
+                       _vm_remap, _vm_remap_new, _vm_wire, _vm_write, _voucher_mach_msg_adopt, 
+                       _voucher_mach_msg_clear, _voucher_mach_msg_revert, _voucher_mach_msg_set, 
+                       _vprintf_stderr_func, _wait4, _waitid, '_waitid$NOCANCEL', 
+                       _work_interval_copy_port, _work_interval_create, _work_interval_destroy, 
+                       _work_interval_get_flags_from_port, _work_interval_instance_alloc, 
+                       _work_interval_instance_clear, _work_interval_instance_finish, 
+                       _work_interval_instance_free, _work_interval_instance_get_complexity, 
+                       _work_interval_instance_get_deadline, _work_interval_instance_get_finish, 
+                       _work_interval_instance_get_id, _work_interval_instance_get_start, 
+                       _work_interval_instance_set_complexity, _work_interval_instance_set_deadline, 
+                       _work_interval_instance_set_finish, _work_interval_instance_set_start, 
+                       _work_interval_instance_start, _work_interval_instance_update, 
+                       _work_interval_join, _work_interval_join_port, _work_interval_leave, 
+                       _work_interval_notify, _work_interval_notify_simple, _write, 
+                       '_write$NOCANCEL', _writev, '_writev$NOCANCEL' ]
+  - targets:         [ arm64-macos, arm64-maccatalyst, arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ ___fstat, ___fstatat, ___fstatfs, ___getfsstat, ___lstat, 
+                       ___stat, ___statfs, __current_pid, _mach_absolute_time_kernel, 
+                       _mach_continuous_time_kernel ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, x86_64h-macos, x86_64h-maccatalyst, 
+                   arm64-macos, arm64-maccatalyst, arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           5F7B0A6E-0315-3171-B806-4CCDB23007F4
+  - target:          x86_64-maccatalyst
+    value:           5F7B0A6E-0315-3171-B806-4CCDB23007F4
+  - target:          x86_64h-macos
+    value:           99FD67E1-20A8-36A7-836D-C8F156C98C5D
+  - target:          x86_64h-maccatalyst
+    value:           99FD67E1-20A8-36A7-836D-C8F156C98C5D
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           748648A3-C1FF-3A75-8CE4-95B8334A6D58
+  - target:          arm64e-maccatalyst
+    value:           748648A3-C1FF-3A75-8CE4-95B8334A6D58
+install-name:    '/usr/lib/system/libsystem_m.dylib'
+current-version: 3226.0.1
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, x86_64h-macos, x86_64h-maccatalyst, 
+                       arm64-macos, arm64-maccatalyst, arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, x86_64h-macos, x86_64h-maccatalyst ]
+    symbols:         [ __FE_DFL_DISABLE_SSE_DENORMS_ENV, ___cos_d4, ___cos_f8, ___fpclassify, 
+                       ___inf, ___inff, ___infl, ___isfinite, ___isinf, ___isnan, 
+                       ___isnormal, ___nan, ___signbit, ___sin_d4, ___sin_f8, __simd_acos_d4, 
+                       __simd_acos_d8, __simd_acos_f16, __simd_acos_f8, __simd_acosh_d4, 
+                       __simd_acosh_d8, __simd_acosh_f16, __simd_acosh_f8, __simd_asin_d4, 
+                       __simd_asin_d8, __simd_asin_f16, __simd_asin_f8, __simd_asinh_d4, 
+                       __simd_asinh_d8, __simd_asinh_f16, __simd_asinh_f8, __simd_atan2_d4, 
+                       __simd_atan2_d8, __simd_atan2_f16, __simd_atan2_f8, __simd_atan_d4, 
+                       __simd_atan_d8, __simd_atan_f16, __simd_atan_f8, __simd_atanh_d4, 
+                       __simd_atanh_d8, __simd_atanh_f16, __simd_atanh_f8, __simd_cbrt_d4, 
+                       __simd_cbrt_d8, __simd_cbrt_f16, __simd_cbrt_f8, __simd_cos_d4, 
+                       __simd_cos_d8, __simd_cos_f16, __simd_cos_f8, __simd_cosh_d4, 
+                       __simd_cosh_d8, __simd_cosh_f16, __simd_cosh_f8, __simd_cospi_d4, 
+                       __simd_cospi_d8, __simd_cospi_f16, __simd_cospi_f8, __simd_erf_d4, 
+                       __simd_erf_d8, __simd_erf_f16, __simd_erf_f8, __simd_erfc_d4, 
+                       __simd_erfc_d8, __simd_erfc_f16, __simd_erfc_f8, __simd_exp10_d4, 
+                       __simd_exp10_d8, __simd_exp10_f16, __simd_exp10_f8, __simd_exp2_d4, 
+                       __simd_exp2_d8, __simd_exp2_f16, __simd_exp2_f8, __simd_exp_d4, 
+                       __simd_exp_d8, __simd_exp_f16, __simd_exp_f8, __simd_expm1_d4, 
+                       __simd_expm1_d8, __simd_expm1_f16, __simd_expm1_f8, __simd_fmod_d4, 
+                       __simd_fmod_d8, __simd_fmod_f16, __simd_fmod_f8, __simd_hypot_d4, 
+                       __simd_hypot_d8, __simd_hypot_f16, __simd_hypot_f8, __simd_lgamma_d4, 
+                       __simd_lgamma_d8, __simd_lgamma_f16, __simd_lgamma_f8, __simd_log10_d4, 
+                       __simd_log10_d8, __simd_log10_f16, __simd_log10_f8, __simd_log1p_d4, 
+                       __simd_log1p_d8, __simd_log1p_f16, __simd_log1p_f8, __simd_log2_d4, 
+                       __simd_log2_d8, __simd_log2_f16, __simd_log2_f8, __simd_log_d4, 
+                       __simd_log_d8, __simd_log_f16, __simd_log_f8, __simd_nextafter_d4, 
+                       __simd_nextafter_d8, __simd_nextafter_f16, __simd_nextafter_f8, 
+                       __simd_pow_d4, __simd_pow_d8, __simd_pow_f16, __simd_pow_f8, 
+                       __simd_remainder_d4, __simd_remainder_d8, __simd_remainder_f16, 
+                       __simd_remainder_f8, __simd_round_d4, __simd_round_d8, __simd_round_f16, 
+                       __simd_round_f8, __simd_sin_d4, __simd_sin_d8, __simd_sin_f16, 
+                       __simd_sin_f8, __simd_sinh_d4, __simd_sinh_d8, __simd_sinh_f16, 
+                       __simd_sinh_f8, __simd_sinpi_d4, __simd_sinpi_d8, __simd_sinpi_f16, 
+                       __simd_sinpi_f8, __simd_tan_d4, __simd_tan_d8, __simd_tan_f16, 
+                       __simd_tan_f8, __simd_tanh_d4, __simd_tanh_d8, __simd_tanh_f16, 
+                       __simd_tanh_f8, __simd_tanpi_d4, __simd_tanpi_d8, __simd_tanpi_f16, 
+                       __simd_tanpi_f8, __simd_tgamma_d4, __simd_tgamma_d8, __simd_tgamma_f16, 
+                       __simd_tgamma_f8, '_acos$fenv_access_off', '_acosf$fenv_access_off', 
+                       '_acosh$fenv_access_off', '_acoshf$fenv_access_off', '_acoshl$fenv_access_off', 
+                       '_acosl$fenv_access_off', '_asin$fenv_access_off', '_asinf$fenv_access_off', 
+                       '_asinh$fenv_access_off', '_asinhf$fenv_access_off', '_asinhl$fenv_access_off', 
+                       '_asinl$fenv_access_off', '_atan$fenv_access_off', '_atan2$fenv_access_off', 
+                       '_atan2f$fenv_access_off', '_atan2l$fenv_access_off', '_atanf$fenv_access_off', 
+                       '_atanh$fenv_access_off', '_atanhf$fenv_access_off', '_atanhl$fenv_access_off', 
+                       '_atanl$fenv_access_off', '_cabs$fenv_access_off', '_cabsf$fenv_access_off', 
+                       '_cabsl$fenv_access_off', '_cacos$fenv_access_off', '_cacosf$fenv_access_off', 
+                       '_cacosh$fenv_access_off', '_cacoshf$fenv_access_off', '_cacoshl$fenv_access_off', 
+                       '_cacosl$fenv_access_off', '_carg$fenv_access_off', '_cargf$fenv_access_off', 
+                       '_cargl$fenv_access_off', '_casin$fenv_access_off', '_casinf$fenv_access_off', 
+                       '_casinh$fenv_access_off', '_casinhf$fenv_access_off', '_casinhl$fenv_access_off', 
+                       '_casinl$fenv_access_off', '_catan$fenv_access_off', '_catanf$fenv_access_off', 
+                       '_catanh$fenv_access_off', '_catanhf$fenv_access_off', '_catanhl$fenv_access_off', 
+                       '_catanl$fenv_access_off', '_cbrt$fenv_access_off', '_cbrtf$fenv_access_off', 
+                       '_cbrtl$fenv_access_off', '_ccos$fenv_access_off', '_ccosf$fenv_access_off', 
+                       '_ccosh$fenv_access_off', '_ccoshf$fenv_access_off', '_ccoshl$fenv_access_off', 
+                       '_ccosl$fenv_access_off', '_ceil$fenv_access_off', '_ceilf$fenv_access_off', 
+                       '_ceill$fenv_access_off', '_cexp$fenv_access_off', '_cexpf$fenv_access_off', 
+                       '_cexpl$fenv_access_off', '_cimag$fenv_access_off', '_cimagf$fenv_access_off', 
+                       '_cimagl$fenv_access_off', '_clog$fenv_access_off', '_clogf$fenv_access_off', 
+                       '_clogl$fenv_access_off', '_conj$fenv_access_off', '_conjf$fenv_access_off', 
+                       '_conjl$fenv_access_off', '_copysign$fenv_access_off', '_copysignf$fenv_access_off', 
+                       '_copysignl$fenv_access_off', '_cos$fenv_access_off', '_cosf$fenv_access_off', 
+                       '_cosh$fenv_access_off', '_coshf$fenv_access_off', '_coshl$fenv_access_off', 
+                       '_cosl$fenv_access_off', '_cpow$fenv_access_off', '_cpowf$fenv_access_off', 
+                       '_cpowl$fenv_access_off', '_cproj$fenv_access_off', '_cprojf$fenv_access_off', 
+                       '_cprojl$fenv_access_off', '_creal$fenv_access_off', '_crealf$fenv_access_off', 
+                       '_creall$fenv_access_off', '_csin$fenv_access_off', '_csinf$fenv_access_off', 
+                       '_csinh$fenv_access_off', '_csinhf$fenv_access_off', '_csinhl$fenv_access_off', 
+                       '_csinl$fenv_access_off', '_csqrt$fenv_access_off', '_csqrtf$fenv_access_off', 
+                       '_csqrtl$fenv_access_off', '_ctan$fenv_access_off', '_ctanf$fenv_access_off', 
+                       '_ctanh$fenv_access_off', '_ctanhf$fenv_access_off', '_ctanhl$fenv_access_off', 
+                       '_ctanl$fenv_access_off', _drem, '_erf$fenv_access_off', '_erfc$fenv_access_off', 
+                       '_erfcf$fenv_access_off', '_erfcl$fenv_access_off', '_erff$fenv_access_off', 
+                       '_erfl$fenv_access_off', '_exp$fenv_access_off', '_exp2$fenv_access_off', 
+                       '_exp2f$fenv_access_off', '_exp2l$fenv_access_off', '_expf$fenv_access_off', 
+                       '_expl$fenv_access_off', '_expm1$fenv_access_off', '_expm1f$fenv_access_off', 
+                       '_expm1l$fenv_access_off', '_fabs$fenv_access_off', '_fabsf$fenv_access_off', 
+                       '_fabsl$fenv_access_off', '_fdim$fenv_access_off', '_fdimf$fenv_access_off', 
+                       '_fdiml$fenv_access_off', _fegetexcept, _fesetexcept, _finite, 
+                       '_floor$fenv_access_off', '_floorf$fenv_access_off', '_floorl$fenv_access_off', 
+                       '_fma$fenv_access_off', '_fmaf$fenv_access_off', '_fmal$fenv_access_off', 
+                       '_fmax$fenv_access_off', '_fmaxf$fenv_access_off', '_fmaxl$fenv_access_off', 
+                       '_fmin$fenv_access_off', '_fminf$fenv_access_off', '_fminl$fenv_access_off', 
+                       '_fmod$fenv_access_off', '_fmodf$fenv_access_off', '_fmodl$fenv_access_off', 
+                       '_frexp$fenv_access_off', '_frexpf$fenv_access_off', '_frexpl$fenv_access_off', 
+                       _gamma, '_gamma$fenv_access_off', '_hypot$fenv_access_off', 
+                       '_hypotf$fenv_access_off', '_hypotl$fenv_access_off', '_ilogb$fenv_access_off', 
+                       '_ilogbf$fenv_access_off', '_ilogbl$fenv_access_off', '_ldexp$fenv_access_off', 
+                       '_ldexpf$fenv_access_off', '_ldexpl$fenv_access_off', '_lgamma$fenv_access_off', 
+                       '_lgamma_r$fenv_access_off', '_lgammaf$fenv_access_off', '_lgammaf_r$fenv_access_off', 
+                       '_lgammal$fenv_access_off', '_lgammal_r$fenv_access_off', 
+                       '_llrint$fenv_access_off', '_llrintf$fenv_access_off', '_llrintl$fenv_access_off', 
+                       '_llround$fenv_access_off', '_llroundf$fenv_access_off', '_llroundl$fenv_access_off', 
+                       '_log$fenv_access_off', '_log10$fenv_access_off', '_log10f$fenv_access_off', 
+                       '_log10l$fenv_access_off', '_log1p$fenv_access_off', '_log1pf$fenv_access_off', 
+                       '_log1pl$fenv_access_off', '_log2$fenv_access_off', '_log2f$fenv_access_off', 
+                       '_log2l$fenv_access_off', '_logb$fenv_access_off', '_logbf$fenv_access_off', 
+                       '_logbl$fenv_access_off', '_logf$fenv_access_off', '_logl$fenv_access_off', 
+                       '_lrint$fenv_access_off', '_lrintf$fenv_access_off', '_lrintl$fenv_access_off', 
+                       '_lround$fenv_access_off', '_lroundf$fenv_access_off', '_lroundl$fenv_access_off', 
+                       _matherr, '_modf$fenv_access_off', '_modff$fenv_access_off', 
+                       '_modfl$fenv_access_off', '_nearbyint$fenv_access_off', '_nearbyintf$fenv_access_off', 
+                       '_nearbyintl$fenv_access_off', '_nextafter$fenv_access_off', 
+                       _nextafterd, '_nextafterf$fenv_access_off', '_nextafterl$fenv_access_off', 
+                       '_nexttoward$fenv_access_off', '_nexttowardf$fenv_access_off', 
+                       '_nexttowardl$fenv_access_off', '_pow$fenv_access_off', '_powf$fenv_access_off', 
+                       '_powl$fenv_access_off', '_remainder$fenv_access_off', '_remainderf$fenv_access_off', 
+                       '_remainderl$fenv_access_off', '_remquo$fenv_access_off', 
+                       '_remquof$fenv_access_off', '_remquol$fenv_access_off', '_rint$fenv_access_off', 
+                       '_rintf$fenv_access_off', '_rintl$fenv_access_off', _rinttol, 
+                       '_round$fenv_access_off', '_roundf$fenv_access_off', '_roundl$fenv_access_off', 
+                       _roundtol, '_scalbln$fenv_access_off', '_scalblnf$fenv_access_off', 
+                       '_scalblnl$fenv_access_off', '_scalbn$fenv_access_off', '_scalbnf$fenv_access_off', 
+                       '_scalbnl$fenv_access_off', _significand, '_sin$fenv_access_off', 
+                       '_sinf$fenv_access_off', '_sinh$fenv_access_off', '_sinhf$fenv_access_off', 
+                       '_sinhl$fenv_access_off', '_sinl$fenv_access_off', '_sqrt$fenv_access_off', 
+                       '_sqrtf$fenv_access_off', '_sqrtl$fenv_access_off', '_tan$fenv_access_off', 
+                       '_tanf$fenv_access_off', '_tanh$fenv_access_off', '_tanhf$fenv_access_off', 
+                       '_tanhl$fenv_access_off', '_tanl$fenv_access_off', '_tgamma$fenv_access_off', 
+                       '_tgammaf$fenv_access_off', '_tgammal$fenv_access_off', '_trunc$fenv_access_off', 
+                       '_truncf$fenv_access_off', '_truncl$fenv_access_off' ]
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, x86_64h-macos, x86_64h-maccatalyst, 
+                       arm64-macos, arm64-maccatalyst, arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ __FE_DFL_ENV, ___Libm_version, ___cos_d2, ___cos_f4, ___cospi, 
+                       ___cospif, ___exp10, ___exp10f, ___fegetfltrounds, ___fpclassifyd, 
+                       ___fpclassifyf, ___fpclassifyl, ___inline_isfinited, ___inline_isfinitef, 
+                       ___inline_isfinitel, ___inline_isinfd, ___inline_isinff, ___inline_isinfl, 
+                       ___inline_isnand, ___inline_isnanf, ___inline_isnanl, ___inline_isnormald, 
+                       ___inline_isnormalf, ___inline_isnormall, ___inline_signbitd, 
+                       ___inline_signbitf, ___inline_signbitl, ___invert_d2, ___invert_d3, 
+                       ___invert_d4, ___invert_f2, ___invert_f3, ___invert_f4, ___isfinited, 
+                       ___isfinitef, ___isfinitel, ___isinfd, ___isinff, ___isinfl, 
+                       ___isnand, ___isnanf, ___isnanl, ___isnormald, ___isnormalf, 
+                       ___isnormall, ___math_errhandling, ___signbitd, ___signbitf, 
+                       ___signbitl, ___sin_d2, ___sin_f4, ___sincos, ___sincos_stret, 
+                       ___sincosf, ___sincosf_stret, ___sincospi, ___sincospi_stret, 
+                       ___sincospif, ___sincospif_stret, ___sinpi, ___sinpif, ___tanpi, 
+                       ___tanpif, __simd_acos_d2, __simd_acos_f4, __simd_acosh_d2, 
+                       __simd_acosh_f4, __simd_asin_d2, __simd_asin_f4, __simd_asinh_d2, 
+                       __simd_asinh_f4, __simd_atan2_d2, __simd_atan2_f4, __simd_atan_d2, 
+                       __simd_atan_f4, __simd_atanh_d2, __simd_atanh_f4, __simd_cbrt_d2, 
+                       __simd_cbrt_f4, __simd_cos_d2, __simd_cos_f4, __simd_cosh_d2, 
+                       __simd_cosh_f4, __simd_cospi_d2, __simd_cospi_f4, __simd_erf_d2, 
+                       __simd_erf_f4, __simd_erfc_d2, __simd_erfc_f4, __simd_exp10_d2, 
+                       __simd_exp10_f4, __simd_exp2_d2, __simd_exp2_f4, __simd_exp_d2, 
+                       __simd_exp_f4, __simd_expm1_d2, __simd_expm1_f4, __simd_fma_d2, 
+                       __simd_fma_f4, __simd_fmod_d2, __simd_fmod_f4, __simd_hypot_d2, 
+                       __simd_hypot_f4, __simd_incircle_pd2, __simd_incircle_pf2, 
+                       __simd_insphere_pd3, __simd_insphere_pf3, __simd_lgamma_d2, 
+                       __simd_lgamma_f4, __simd_log10_d2, __simd_log10_f4, __simd_log1p_d2, 
+                       __simd_log1p_f4, __simd_log2_d2, __simd_log2_f4, __simd_log_d2, 
+                       __simd_log_f4, __simd_nextafter_d2, __simd_nextafter_f4, __simd_orient_pd2, 
+                       __simd_orient_pd3, __simd_orient_pf2, __simd_orient_pf3, __simd_orient_vd2, 
+                       __simd_orient_vd3, __simd_orient_vf2, __simd_orient_vf3, __simd_pow_d2, 
+                       __simd_pow_f4, __simd_remainder_d2, __simd_remainder_f4, __simd_round_d2, 
+                       __simd_round_f4, __simd_sin_d2, __simd_sin_f4, __simd_sincos_d2, 
+                       __simd_sincos_f4, __simd_sincospi_d2, __simd_sincospi_f4, 
+                       __simd_sinh_d2, __simd_sinh_f4, __simd_sinpi_d2, __simd_sinpi_f4, 
+                       __simd_tan_d2, __simd_tan_f4, __simd_tanh_d2, __simd_tanh_f4, 
+                       __simd_tanpi_d2, __simd_tanpi_f4, __simd_tgamma_d2, __simd_tgamma_f4, 
+                       _acos, _acosf, _acosh, _acoshf, _acoshl, _acosl, _asin, _asinf, 
+                       _asinh, _asinhf, _asinhl, _asinl, _atan, _atan2, _atan2f, 
+                       _atan2l, _atanf, _atanh, _atanhf, _atanhl, _atanl, _cabs, 
+                       _cabsf, _cabsl, _cacos, _cacosf, _cacosh, _cacoshf, _cacoshl, 
+                       _cacosl, _carg, _cargf, _cargl, _casin, _casinf, _casinh, 
+                       _casinhf, _casinhl, _casinl, _catan, _catanf, _catanh, _catanhf, 
+                       _catanhl, _catanl, _cbrt, _cbrtf, _cbrtl, _ccos, _ccosf, _ccosh, 
+                       _ccoshf, _ccoshl, _ccosl, _ceil, _ceilf, _ceill, _cexp, _cexpf, 
+                       _cexpl, _cimag, _cimagf, _cimagl, _clog, _clogf, _clogl, _conj, 
+                       _conjf, _conjl, _copysign, _copysignf, _copysignl, _cos, _cosf, 
+                       _cosh, _coshf, _coshl, _cosl, _cpow, _cpowf, _cpowl, _cproj, 
+                       _cprojf, _cprojl, _creal, _crealf, _creall, _csin, _csinf, 
+                       _csinh, _csinhf, _csinhl, _csinl, _csqrt, _csqrtf, _csqrtl, 
+                       _ctan, _ctanf, _ctanh, _ctanhf, _ctanhl, _ctanl, _erf, _erfc, 
+                       _erfcf, _erfcl, _erff, _erfl, _exp, _exp2, _exp2f, _exp2l, 
+                       _expf, _expl, _expm1, _expm1f, _expm1l, _fabs, _fabsf, _fabsl, 
+                       _fdim, _fdimf, _fdiml, _feclearexcept, _fegetenv, _fegetexceptflag, 
+                       _fegetround, _feholdexcept, _feraiseexcept, _fesetenv, _fesetexceptflag, 
+                       _fesetround, _fetestexcept, _feupdateenv, _floor, _floorf, 
+                       _floorl, _fma, _fmaf, _fmal, _fmax, _fmaxf, _fmaxl, _fmin, 
+                       _fminf, _fminl, _fmod, _fmodf, _fmodl, _frexp, _frexpf, _frexpl, 
+                       _hypot, _hypotf, _hypotl, _ilogb, _ilogbf, _ilogbl, _isinf, 
+                       _isnan, _j0, _j1, _jn, _ldexp, _ldexpf, _ldexpl, _lgamma, 
+                       _lgamma_r, _lgammaf, _lgammaf_r, _lgammal, _lgammal_r, _llrint, 
+                       _llrintf, _llrintl, _llround, _llroundf, _llroundl, _log, 
+                       _log10, _log10f, _log10l, _log1p, _log1pf, _log1pl, _log2, 
+                       _log2f, _log2l, _logb, _logbf, _logbl, _logf, _logl, _lrint, 
+                       _lrintf, _lrintl, _lround, _lroundf, _lroundl, _matrix_identity_double2x2, 
+                       _matrix_identity_double3x3, _matrix_identity_double4x4, _matrix_identity_float2x2, 
+                       _matrix_identity_float3x3, _matrix_identity_float4x4, _modf, 
+                       _modff, _modfl, _nan, _nanf, _nanl, _nearbyint, _nearbyintf, 
+                       _nearbyintl, _nextafter, _nextafterf, _nextafterl, _nexttoward, 
+                       _nexttowardf, _nexttowardl, _pow, _powf, _powl, _remainder, 
+                       _remainderf, _remainderl, _remquo, _remquof, _remquol, _rint, 
+                       _rintf, _rintl, _round, _roundf, _roundl, _scalb, _scalbln, 
+                       _scalblnf, _scalblnl, _scalbn, _scalbnf, _scalbnl, _signgam, 
+                       _sin, _sinf, _sinh, _sinhf, _sinhl, _sinl, _sqrt, _sqrtf, 
+                       _sqrtl, _tan, _tanf, _tanh, _tanhf, _tanhl, _tanl, _tgamma, 
+                       _tgammaf, _tgammal, _trunc, _truncf, _truncl, _y0, _y1, _yn ]
+  - targets:         [ arm64-macos, arm64-maccatalyst, arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ __FE_DFL_DISABLE_DENORMS_ENV ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           D95D8C17-9F95-3076-A449-FBC4D1E9AD57
+  - target:          x86_64-maccatalyst
+    value:           D95D8C17-9F95-3076-A449-FBC4D1E9AD57
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           030A8CB7-CD53-32E1-A0CC-6AC7D7DE93F1
+  - target:          arm64e-maccatalyst
+    value:           030A8CB7-CD53-32E1-A0CC-6AC7D7DE93F1
+install-name:    '/usr/lib/system/libsystem_malloc.dylib'
+current-version: 409.40.6
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ ___mach_stack_logging_copy_uniquing_table, ___mach_stack_logging_enumerate_records, 
+                       ___mach_stack_logging_frames_for_uniqued_stack, ___mach_stack_logging_get_frames, 
+                       ___mach_stack_logging_get_frames_for_stackid, ___mach_stack_logging_set_file_path, 
+                       ___mach_stack_logging_shared_memory_address, ___mach_stack_logging_stackid_for_vm_region, 
+                       ___mach_stack_logging_start_reading, ___mach_stack_logging_stop_reading, 
+                       ___mach_stack_logging_uniquing_table_copy_from_serialized, 
+                       ___mach_stack_logging_uniquing_table_read_stack, ___mach_stack_logging_uniquing_table_release, 
+                       ___mach_stack_logging_uniquing_table_retain, ___mach_stack_logging_uniquing_table_serialize, 
+                       ___mach_stack_logging_uniquing_table_sizeof, ___malloc_init, 
+                       ___malloc_late_init, __malloc_fork_child, __malloc_fork_parent, 
+                       __malloc_fork_prepare, __malloc_no_asl_log, __os_cpu_number_override, 
+                       _aligned_alloc, _calloc, _free, _mag_set_thread_index, _malloc, 
+                       _malloc_check_counter, _malloc_check_each, _malloc_check_start, 
+                       _malloc_claimed_address, _malloc_create_legacy_default_zone, 
+                       _malloc_create_zone, _malloc_debug, _malloc_default_purgeable_zone, 
+                       _malloc_default_zone, _malloc_destroy_zone, _malloc_engaged_nano, 
+                       _malloc_enter_process_memory_limit_warn_mode, _malloc_error, 
+                       _malloc_freezedry, _malloc_get_all_zones, _malloc_get_thread_options, 
+                       _malloc_get_zone_name, _malloc_good_size, _malloc_jumpstart, 
+                       _malloc_logger, _malloc_make_nonpurgeable, _malloc_make_purgeable, 
+                       _malloc_memory_event_handler, _malloc_num_zones, _malloc_num_zones_allocated, 
+                       _malloc_printf, _malloc_register_stack_logger, _malloc_set_thread_options, 
+                       _malloc_set_zone_name, _malloc_singlethreaded, _malloc_size, 
+                       _malloc_zero_on_free_disable, _malloc_zone_batch_free, _malloc_zone_batch_malloc, 
+                       _malloc_zone_calloc, _malloc_zone_check, _malloc_zone_claimed_address, 
+                       _malloc_zone_disable_discharge_checking, _malloc_zone_discharge, 
+                       _malloc_zone_enable_discharge_checking, _malloc_zone_enumerate_discharged_pointers, 
+                       _malloc_zone_free, _malloc_zone_from_ptr, _malloc_zone_log, 
+                       _malloc_zone_malloc, _malloc_zone_memalign, _malloc_zone_pressure_relief, 
+                       _malloc_zone_print, _malloc_zone_print_ptr_info, _malloc_zone_realloc, 
+                       _malloc_zone_register, _malloc_zone_statistics, _malloc_zone_unregister, 
+                       _malloc_zone_valloc, _malloc_zones, _mstats, _pgm_diagnose_fault_from_crash_reporter, 
+                       _pgm_disable_for_current_thread, _posix_memalign, _quarantine_diagnose_fault_from_crash_reporter, 
+                       _realloc, '_reallocarray$DARWIN_EXTSN', '_reallocarrayf$DARWIN_EXTSN', 
+                       _scalable_zone_info, _scalable_zone_statistics, _set_malloc_singlethreaded, 
+                       _stack_logging_enable_logging, _szone_check_counter, _szone_check_modulo, 
+                       _szone_check_start, _tiny_print_region_free_list, _turn_off_stack_logging, 
+                       _turn_on_stack_logging, _valloc, _vfree, _zeroify_scalable_zone ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           33130846-6A1D-33AA-BC75-06695EFCBF20
+  - target:          x86_64-maccatalyst
+    value:           33130846-6A1D-33AA-BC75-06695EFCBF20
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           4972C105-1F4D-38BF-87C0-4724101B2CFA
+  - target:          arm64e-maccatalyst
+    value:           4972C105-1F4D-38BF-87C0-4724101B2CFA
+install-name:    '/usr/lib/system/libsystem_networkextension.dylib'
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _NEHelperCacheAddRedirectedAddress, _NEHelperCacheClearRedirectedAddresses, 
+                       _NEHelperCacheClearUUIDs, _NEHelperCacheCopyAppUUIDMapping, 
+                       _NEHelperCacheCopyAppUUIDMappingExtended, _NEHelperCacheCopyAppUUIDMappingForUIDExtended, 
+                       _NEHelperCacheCopySigningIdentifierMapping, _NEHelperCacheSetDomainDictionaries, 
+                       _NEHelperCacheSetRoutes, _NEHelperCopyAggregatePathRules, 
+                       _NEHelperCopyAppInfo, _NEHelperCopyCurrentNetworkAsync, _NEHelperCopyCurrentNetworkInfo, 
+                       _NEHelperCopyPerAppDomains, _NEHelperCopyResponse, _NEHelperGetIKESocket, 
+                       _NEHelperGetIKESocketWithResult, _NEHelperGetKernelControlSocket, 
+                       _NEHelperGetKernelControlSocketExtended, _NEHelperGetNECPSessionFD, 
+                       _NEHelperGetPFKeySocket, _NEHelperHandleConfigurationsChangedBySC, 
+                       _NEHelperInit, _NEHelperInterfaceRemoveAddress, _NEHelperInterfaceSetAddress, 
+                       _NEHelperInterfaceSetAddressWithLifetime, _NEHelperInterfaceSetMTU, 
+                       _NEHelperInterfaceSetOption, _NEHelperSendRequest, _NEHelperSettingsRemove, 
+                       _NEHelperSettingsSetArray, _NEHelperSettingsSetBool, _NEHelperSettingsSetNumber, 
+                       _NEHelperVPNConfigurationExists, _NEHelperVPNSetEnabled, _g_ne_read_uuid_cache, 
+                       _g_ne_uuid_cache_hit, _ne_copy_cached_bundle_identifier_for_uuid, 
+                       _ne_copy_cached_preferred_bundle_for_bundle_identifier, _ne_copy_cached_uuids_for_bundle_identifier, 
+                       _ne_copy_signature_info_for_pid, _ne_copy_signing_identifier_for_pid, 
+                       _ne_copy_uuid_cache, _ne_force_reset_uuid_cache, _ne_get_configuration_generation, 
+                       _ne_is_sockaddr_valid, _ne_log_large_obj, _ne_log_obj, _ne_print_backtrace, 
+                       _ne_privacy_dns_netagent_id, _ne_privacy_proxy_netagent_id, 
+                       _ne_session_add_necp_drop_dest_from_dest_list, _ne_session_add_necp_drop_dest_from_path, 
+                       _ne_session_address_matches_subnets, _ne_session_agent_get_advisory, 
+                       _ne_session_agent_get_advisory_interface_index, _ne_session_always_on_vpn_configs_present, 
+                       _ne_session_always_on_vpn_configs_present_at_boot, _ne_session_app_vpn_configs_present, 
+                       _ne_session_cancel, _ne_session_clear_caches, _ne_session_content_filter_configs_present, 
+                       _ne_session_copy_app_data_from_flow_divert_socket, _ne_session_copy_app_data_from_flow_divert_token, 
+                       _ne_session_copy_os_version_string, _ne_session_copy_policy_match, 
+                       _ne_session_copy_security_session_info, _ne_session_copy_socket_attributes, 
+                       _ne_session_copy_socket_domain_attributes, _ne_session_create, 
+                       _ne_session_disable_restrictions, _ne_session_dns_proxy_configs_present, 
+                       _ne_session_dns_settings_configs_present, _ne_session_establish_ipc, 
+                       _ne_session_fallback_advisory, _ne_session_fallback_default, 
+                       _ne_session_get_config_id_from_network_agent, _ne_session_get_configuration_id, 
+                       _ne_session_get_info, _ne_session_get_info2, _ne_session_get_status, 
+                       _ne_session_info_type_to_string, _ne_session_initialize_necp_drop_all, 
+                       _ne_session_is_always_on_vpn_enabled, _ne_session_is_safeboot, 
+                       _ne_session_local_communication_configs_present, _ne_session_local_communication_send_info, 
+                       _ne_session_manager_get_pid, _ne_session_manager_has_active_sessions, 
+                       _ne_session_manager_is_running, _ne_session_on_demand_configs_present, 
+                       _ne_session_path_controller_configs_present, _ne_session_policy_copy_flow_divert_token, 
+                       _ne_session_policy_copy_flow_divert_token_with_key, _ne_session_policy_match_get_filter_unit, 
+                       _ne_session_policy_match_get_flow_divert_unit, _ne_session_policy_match_get_scoped_interface_index, 
+                       _ne_session_policy_match_get_service, _ne_session_policy_match_get_service_action, 
+                       _ne_session_policy_match_get_service_type, _ne_session_policy_match_is_drop, 
+                       _ne_session_policy_match_is_flow_divert, _ne_session_policy_match_service_is_registered, 
+                       _ne_session_release, _ne_session_retain, _ne_session_send_barrier, 
+                       _ne_session_service_get_dns_service_id, _ne_session_service_get_dns_service_id_for_interface, 
+                       _ne_session_service_matches_address, _ne_session_service_matches_address_for_interface, 
+                       _ne_session_set_event_handler, _ne_session_set_socket_attributes, 
+                       _ne_session_set_socket_context_attribute, _ne_session_set_socket_tracker_attributes, 
+                       _ne_session_should_disable_nexus, _ne_session_start, _ne_session_start_on_behalf_of, 
+                       _ne_session_start_with_options, _ne_session_status_to_string, 
+                       _ne_session_stop, _ne_session_stop_all_with_plugin_type, _ne_session_stop_reason_to_string, 
+                       _ne_session_type_to_string, _ne_session_use_as_system_vpn, 
+                       _ne_session_vod_evaluate_connection_present, _ne_session_vpn_include_all_networks_configs_present, 
+                       _ne_socket_set_attribution, _ne_socket_set_domains, _ne_socket_set_is_app_initiated, 
+                       _ne_socket_set_website_attribution, _ne_tracker_build_cache, 
+                       _ne_tracker_build_trie, _ne_tracker_check_info_changed, _ne_tracker_clear_cache, 
+                       _ne_tracker_context_get_domain, _ne_tracker_context_get_domain_owner, 
+                       _ne_tracker_context_is_from_app_list, _ne_tracker_context_is_from_web_list, 
+                       _ne_tracker_get_ddg_dictionary, _ne_tracker_lookup_app_domains, 
+                       _ne_tracker_set_test_domains, _ne_tracker_validate_domain, 
+                       _ne_trie_free, _ne_trie_has_high_ascii, _ne_trie_init, _ne_trie_init_from_file, 
+                       _ne_trie_insert, _ne_trie_save_to_file, _ne_trie_search, _necp_drop_dest_copy_dest_entry_list, 
+                       _nehelper_copy_connection_for_delegate_class, _nehelper_queue, 
+                       _nelog_is_debug_logging_enabled, _nelog_is_extra_vpn_logging_enabled, 
+                       _nelog_is_info_logging_enabled ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           1F9FBDD3-694A-3FF7-A232-F07DF4845ABE
+  - target:          x86_64-maccatalyst
+    value:           1F9FBDD3-694A-3FF7-A232-F07DF4845ABE
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           B2C5AAD6-13E5-3E2E-8DFC-601BAED4AA96
+  - target:          arm64e-maccatalyst
+    value:           B2C5AAD6-13E5-3E2E-8DFC-601BAED4AA96
+install-name:    '/usr/lib/system/libsystem_notify.dylib'
+current-version: 306
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ __notify_fork_child, _notify_cancel, _notify_check, _notify_dump_status, 
+                       _notify_get_event, _notify_get_state, _notify_is_valid_token, 
+                       _notify_monitor_file, _notify_peek, _notify_post, _notify_register_check, 
+                       _notify_register_dispatch, _notify_register_file_descriptor, 
+                       _notify_register_mach_port, _notify_register_plain, _notify_register_signal, 
+                       _notify_resume, _notify_resume_pid, _notify_set_options, _notify_set_state, 
+                       _notify_simple_post, _notify_suspend, _notify_suspend_pid ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           F07558DB-8B15-3D96-93F9-3A61BBD52F25
+  - target:          x86_64-maccatalyst
+    value:           F07558DB-8B15-3D96-93F9-3A61BBD52F25
+  - target:          arm64-macos
+    value:           372B6A5F-EE6F-3F9C-84D1-E8027DB6FA17
+  - target:          arm64-maccatalyst
+    value:           372B6A5F-EE6F-3F9C-84D1-E8027DB6FA17
+  - target:          arm64e-macos
+    value:           78189670-2F47-332C-9A59-A210157AA97B
+  - target:          arm64e-maccatalyst
+    value:           78189670-2F47-332C-9A59-A210157AA97B
+install-name:    '/usr/lib/system/libsystem_platform.dylib'
+current-version: 288
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
+    symbols:         [ '_OSAtomicFifoDequeue$VARIANT$PFZ', '_OSAtomicFifoDequeue$VARIANT$UnfairLock', 
+                       '_OSAtomicFifoEnqueue$VARIANT$PFZ', '_OSAtomicFifoEnqueue$VARIANT$UnfairLock', 
+                       ___no_overread_variant_setup, __sigtramp, _bzero_sse_np, _longjmperror, 
+                       _memmove_sse_np, _memset_pattern16_sse_np, _memset_pattern4_sse_np, 
+                       _memset_pattern8_sse_np, _memset_sse_np ]
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _OSAtomicAdd32, _OSAtomicAdd32Barrier, _OSAtomicAdd64, _OSAtomicAdd64Barrier, 
+                       _OSAtomicAnd32, _OSAtomicAnd32Barrier, _OSAtomicAnd32Orig, 
+                       _OSAtomicAnd32OrigBarrier, _OSAtomicCompareAndSwap32, _OSAtomicCompareAndSwap32Barrier, 
+                       _OSAtomicCompareAndSwap64, _OSAtomicCompareAndSwap64Barrier, 
+                       _OSAtomicCompareAndSwapInt, _OSAtomicCompareAndSwapIntBarrier, 
+                       _OSAtomicCompareAndSwapLong, _OSAtomicCompareAndSwapLongBarrier, 
+                       _OSAtomicCompareAndSwapPtr, _OSAtomicCompareAndSwapPtrBarrier, 
+                       _OSAtomicDecrement32, _OSAtomicDecrement32Barrier, _OSAtomicDecrement64, 
+                       _OSAtomicDecrement64Barrier, _OSAtomicDequeue, _OSAtomicEnqueue, 
+                       _OSAtomicFifoDequeue, _OSAtomicFifoEnqueue, _OSAtomicIncrement32, 
+                       _OSAtomicIncrement32Barrier, _OSAtomicIncrement64, _OSAtomicIncrement64Barrier, 
+                       _OSAtomicOr32, _OSAtomicOr32Barrier, _OSAtomicOr32Orig, _OSAtomicOr32OrigBarrier, 
+                       _OSAtomicTestAndClear, _OSAtomicTestAndClearBarrier, _OSAtomicTestAndSet, 
+                       _OSAtomicTestAndSetBarrier, _OSAtomicXor32, _OSAtomicXor32Barrier, 
+                       _OSAtomicXor32Orig, _OSAtomicXor32OrigBarrier, _OSMemoryBarrier, 
+                       _OSSpinLockLock, _OSSpinLockTry, _OSSpinLockUnlock, __OSSpinLockLockSlow, 
+                       ___bzero, ___libplatform_init, ___os_log_simple_offset, ___os_once_reset, 
+                       ___platform_sigaction, __longjmp, __os_alloc_once, __os_lock_type_eliding, 
+                       __os_lock_type_handoff, __os_lock_type_nospin, __os_lock_type_spin, 
+                       __os_lock_type_transactional, __os_lock_type_unfair, __os_log_simple, 
+                       __os_log_simple_parse, __os_log_simple_parse_identifiers, 
+                       __os_log_simple_parse_message, __os_log_simple_parse_subsystem, 
+                       __os_log_simple_parse_timestamp, __os_log_simple_parse_type, 
+                       __os_log_simple_reinit_4launchd, __os_log_simple_send, __os_log_simple_shim, 
+                       __os_nospin_lock_lock, __os_nospin_lock_trylock, __os_nospin_lock_unlock, 
+                       __os_once, __os_semaphore_create, __os_semaphore_dispose, 
+                       __os_semaphore_signal, __os_semaphore_wait, __platform_bzero, 
+                       __platform_memccpy, __platform_memchr, __platform_memcmp, 
+                       __platform_memcmp_zero_aligned8, __platform_memmove, __platform_memset, 
+                       __platform_memset_pattern16, __platform_memset_pattern4, __platform_memset_pattern8, 
+                       __platform_strchr, __platform_strcmp, __platform_strcpy, __platform_strlcat, 
+                       __platform_strlcpy, __platform_strlen, __platform_strncmp, 
+                       __platform_strncpy, __platform_strnlen, __platform_strstr, 
+                       __setjmp, __simple_asl_get_fd, __simple_asl_log, __simple_asl_log_prog, 
+                       __simple_asl_msg_new, __simple_asl_msg_set, __simple_asl_send, 
+                       __simple_dprintf, __simple_esappend, __simple_esprintf, __simple_getenv, 
+                       __simple_put, __simple_putline, __simple_salloc, __simple_sappend, 
+                       __simple_sfree, __simple_sprintf, __simple_sresize, __simple_string, 
+                       __simple_vdprintf, __simple_vesprintf, __simple_vsprintf, 
+                       __spin_lock, __spin_lock_try, __spin_unlock, _ffs, _ffsl, 
+                       _ffsll, _fls, _flsl, _flsll, _getcontext, _longjmp, _makecontext, 
+                       _os_lock_lock, _os_lock_trylock, _os_lock_unlock, _os_log_simple_now, 
+                       _os_log_simple_type_from_asl, _os_unfair_lock_assert_not_owner, 
+                       _os_unfair_lock_assert_owner, _os_unfair_lock_lock, _os_unfair_lock_lock_no_tsd, 
+                       _os_unfair_lock_lock_with_options, _os_unfair_lock_trylock, 
+                       _os_unfair_lock_unlock, _os_unfair_lock_unlock_no_tsd, _os_unfair_recursive_lock_lock_with_options, 
+                       _os_unfair_recursive_lock_owned, _os_unfair_recursive_lock_trylock, 
+                       _os_unfair_recursive_lock_tryunlock4objc, _os_unfair_recursive_lock_unlock, 
+                       _os_unfair_recursive_lock_unlock_forked_child, _platform_task_attach, 
+                       _platform_task_copy_next_thread, _platform_task_detach, _platform_task_is_64_bit, 
+                       _platform_task_perform, _platform_task_resume_threads, _platform_task_suspend_threads, 
+                       _platform_task_update_threads, _platform_thread_abort_safely, 
+                       _platform_thread_get_pthread, _platform_thread_get_state, 
+                       _platform_thread_get_unique_id, _platform_thread_info, _platform_thread_perform, 
+                       _platform_thread_release, _platform_thread_resume, _platform_thread_set_state, 
+                       _platform_thread_suspend, _setcontext, _setjmp, _siglongjmp, 
+                       _sigsetjmp, _spin_lock, _spin_lock_try, _spin_unlock, _swapcontext, 
+                       _sys_cache_control, _sys_dcache_flush, _sys_icache_invalidate ]
+  - targets:         [ arm64-macos, arm64-maccatalyst, arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ __ctx_done ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           13B5E252-77D1-31E1-888D-1C5F4426EA87
+  - target:          x86_64-maccatalyst
+    value:           13B5E252-77D1-31E1-888D-1C5F4426EA87
+  - target:          arm64-macos
+    value:           030D2641-514F-373F-9688-582D9D3B369A
+  - target:          arm64-maccatalyst
+    value:           030D2641-514F-373F-9688-582D9D3B369A
+  - target:          arm64e-macos
+    value:           886CACA0-5762-3640-8DB2-3FA3B911C062
+  - target:          arm64e-maccatalyst
+    value:           886CACA0-5762-3640-8DB2-3FA3B911C062
+install-name:    '/usr/lib/system/libsystem_pthread.dylib'
+current-version: 514
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ ____chkstk_darwin, ___is_threaded, ___pthread_init, ___pthread_late_init, 
+                       ___pthread_workqueue_setkill, ___unix_conforming, __pthread_atfork_child, 
+                       __pthread_atfork_child_handlers, __pthread_atfork_parent, 
+                       __pthread_atfork_parent_handlers, __pthread_atfork_prepare, 
+                       __pthread_atfork_prepare_handlers, __pthread_clear_qos_tsd, 
+                       __pthread_exit_if_canceled, __pthread_fork_child, __pthread_fork_child_postinit, 
+                       __pthread_fork_parent, __pthread_fork_prepare, __pthread_is_threaded, 
+                       __pthread_mutex_enable_legacy_mode, __pthread_override_qos_class_end_direct, 
+                       __pthread_override_qos_class_start_direct, __pthread_qos_class_and_override_decode, 
+                       __pthread_qos_class_and_override_encode, __pthread_qos_class_decode, 
+                       __pthread_qos_class_encode, __pthread_qos_class_encode_workqueue, 
+                       __pthread_qos_override_end_direct, __pthread_qos_override_start_direct, 
+                       __pthread_sched_pri_decode, __pthread_sched_pri_encode, __pthread_self, 
+                       __pthread_set_properties_self, __pthread_set_self, __pthread_setspecific_static, 
+                       __pthread_start, __pthread_tsd_shared_cache_first, __pthread_tsd_shared_cache_last, 
+                       __pthread_workloop_create, __pthread_workloop_destroy, __pthread_workqueue_add_cooperativethreads, 
+                       __pthread_workqueue_addthreads, __pthread_workqueue_asynchronous_override_add, 
+                       __pthread_workqueue_asynchronous_override_reset_all_self, 
+                       __pthread_workqueue_asynchronous_override_reset_self, __pthread_workqueue_init, 
+                       __pthread_workqueue_init_with_kevent, __pthread_workqueue_init_with_workloop, 
+                       __pthread_workqueue_override_reset, __pthread_workqueue_override_start_direct, 
+                       __pthread_workqueue_override_start_direct_check_owner, __pthread_workqueue_set_event_manager_priority, 
+                       __pthread_workqueue_should_narrow, __pthread_workqueue_supported, 
+                       __pthread_wqthread, __pthread_yield_to_enqueuer_4dispatch, 
+                       _cthread_yield, _posix_spawnattr_get_qos_class_np, _posix_spawnattr_set_qos_class_np, 
+                       _pthread_atfork, _pthread_attr_destroy, _pthread_attr_get_qos_class_np, 
+                       _pthread_attr_getdetachstate, _pthread_attr_getguardsize, 
+                       _pthread_attr_getinheritsched, _pthread_attr_getschedparam, 
+                       _pthread_attr_getschedpolicy, _pthread_attr_getscope, _pthread_attr_getstack, 
+                       _pthread_attr_getstackaddr, _pthread_attr_getstacksize, _pthread_attr_init, 
+                       _pthread_attr_set_qos_class_np, _pthread_attr_setcpupercent_np, 
+                       _pthread_attr_setdetachstate, _pthread_attr_setguardsize, 
+                       _pthread_attr_setinheritsched, _pthread_attr_setschedparam, 
+                       _pthread_attr_setschedpolicy, _pthread_attr_setscope, _pthread_attr_setstack, 
+                       _pthread_attr_setstackaddr, _pthread_attr_setstacksize, _pthread_cancel, 
+                       _pthread_chdir_np, _pthread_cond_broadcast, _pthread_cond_destroy, 
+                       _pthread_cond_init, _pthread_cond_signal, _pthread_cond_signal_thread_np, 
+                       _pthread_cond_timedwait, '_pthread_cond_timedwait$NOCANCEL', 
+                       _pthread_cond_timedwait_relative_np, _pthread_cond_wait, '_pthread_cond_wait$NOCANCEL', 
+                       _pthread_condattr_destroy, _pthread_condattr_getpshared, _pthread_condattr_init, 
+                       _pthread_condattr_setpshared, _pthread_cpu_number_np, _pthread_create, 
+                       _pthread_create_from_mach_thread, _pthread_create_suspended_np, 
+                       _pthread_create_with_workgroup_np, _pthread_current_stack_contains_np, 
+                       _pthread_dependency_fulfill_np, _pthread_dependency_init_np, 
+                       _pthread_dependency_wait_np, _pthread_detach, _pthread_equal, 
+                       _pthread_exit, _pthread_fchdir_np, _pthread_from_mach_thread_np, 
+                       _pthread_get_qos_class_np, _pthread_get_stackaddr_np, _pthread_get_stacksize_np, 
+                       _pthread_getconcurrency, _pthread_getname_np, _pthread_getschedparam, 
+                       _pthread_getspecific, _pthread_install_workgroup_functions_np, 
+                       _pthread_introspection_getspecific_np, _pthread_introspection_hook_install, 
+                       _pthread_introspection_setspecific_np, _pthread_is_threaded_np, 
+                       _pthread_jit_write_freeze_callbacks_np, _pthread_jit_write_protect_np, 
+                       _pthread_jit_write_protect_supported_np, _pthread_jit_write_with_callback_np, 
+                       _pthread_join, '_pthread_join$NOCANCEL', _pthread_key_create, 
+                       _pthread_key_delete, _pthread_key_init_np, _pthread_kill, 
+                       _pthread_layout_offsets, _pthread_mach_thread_np, _pthread_main_np, 
+                       _pthread_main_thread_np, _pthread_mutex_destroy, _pthread_mutex_getprioceiling, 
+                       _pthread_mutex_init, _pthread_mutex_lock, _pthread_mutex_setprioceiling, 
+                       _pthread_mutex_trylock, _pthread_mutex_unlock, _pthread_mutexattr_destroy, 
+                       _pthread_mutexattr_getpolicy_np, _pthread_mutexattr_getprioceiling, 
+                       _pthread_mutexattr_getprotocol, _pthread_mutexattr_getpshared, 
+                       _pthread_mutexattr_gettype, _pthread_mutexattr_init, _pthread_mutexattr_setpolicy_np, 
+                       _pthread_mutexattr_setprioceiling, _pthread_mutexattr_setprotocol, 
+                       _pthread_mutexattr_setpshared, _pthread_mutexattr_settype, 
+                       _pthread_once, _pthread_override_qos_class_end_np, _pthread_override_qos_class_start_np, 
+                       _pthread_prefer_alternate_amx_self, _pthread_prefer_alternate_cluster_self, 
+                       _pthread_qos_max_parallelism, _pthread_rwlock_destroy, _pthread_rwlock_init, 
+                       _pthread_rwlock_rdlock, _pthread_rwlock_tryrdlock, _pthread_rwlock_trywrlock, 
+                       _pthread_rwlock_unlock, _pthread_rwlock_wrlock, _pthread_rwlockattr_destroy, 
+                       _pthread_rwlockattr_getpshared, _pthread_rwlockattr_init, 
+                       _pthread_rwlockattr_setpshared, _pthread_self, _pthread_self_is_exiting_np, 
+                       _pthread_set_fixedpriority_self, _pthread_set_qos_class_np, 
+                       _pthread_set_qos_class_self_np, _pthread_set_timeshare_self, 
+                       _pthread_setcancelstate, _pthread_setcanceltype, _pthread_setconcurrency, 
+                       _pthread_setname_np, _pthread_setschedparam, _pthread_setspecific, 
+                       _pthread_sigmask, _pthread_stack_frame_decode_np, _pthread_testcancel, 
+                       _pthread_threadid_np, _pthread_time_constraint_max_parallelism, 
+                       _pthread_workqueue_addthreads_np, _pthread_workqueue_setdispatch_np, 
+                       _pthread_workqueue_setdispatchoffset_np, _pthread_workqueue_setup, 
+                       _pthread_yield_np, _qos_class_main, _qos_class_self, _sched_get_priority_max, 
+                       _sched_get_priority_min, _sched_yield, _sigwait, '_sigwait$NOCANCEL', 
+                       _start_wqthread, _thread_chkstk_darwin, _thread_start ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           A064D0A7-139F-33E5-959C-7067CF94DC2E
+  - target:          x86_64-maccatalyst
+    value:           A064D0A7-139F-33E5-959C-7067CF94DC2E
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           3ADBD543-3E57-332F-972C-A958D9E4FBF8
+  - target:          arm64e-maccatalyst
+    value:           3ADBD543-3E57-332F-972C-A958D9E4FBF8
+install-name:    '/usr/lib/system/libsystem_sandbox.dylib'
+current-version: 1845.41.2
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _APP_SANDBOX_IOKIT_CLIENT, _APP_SANDBOX_MACH, _APP_SANDBOX_READ, 
+                       _APP_SANDBOX_READ_WRITE, _IOS_SANDBOX_APPLICATION_GROUP, _IOS_SANDBOX_CONTAINER, 
+                       _SANDBOX_CHECK_ALLOW_APPROVAL, _SANDBOX_CHECK_CANONICAL, _SANDBOX_CHECK_NOFOLLOW, 
+                       _SANDBOX_CHECK_NO_APPROVAL, _SANDBOX_CHECK_NO_REPORT, _SANDBOX_CHECK_POSIX_READABLE, 
+                       _SANDBOX_EXTENSION_CANONICAL, _SANDBOX_EXTENSION_DEFAULT, 
+                       _SANDBOX_EXTENSION_MACL_LEARNING, _SANDBOX_EXTENSION_MAGIC, 
+                       _SANDBOX_EXTENSION_NOFOLLOW, _SANDBOX_EXTENSION_NO_REPORT, 
+                       _SANDBOX_EXTENSION_NO_STORAGE_CLASS, _SANDBOX_EXTENSION_PREFIXMATCH, 
+                       _SANDBOX_EXTENSION_UNRESOLVED, _SANDBOX_EXTENSION_USER_INTENT, 
+                       __amkrtemp, __sandbox_in_a_container, __sandbox_register_app_bundle_0, 
+                       __sandbox_register_app_bundle_1, _gpu_bundle_find_trusted, 
+                       _gpu_bundle_is_path_trusted, _kSBXProfileNoInternet, _kSBXProfileNoNetwork, 
+                       _kSBXProfileNoWrite, _kSBXProfileNoWriteExceptTemporary, _kSBXProfilePureComputation, 
+                       _kSandboxAppBundleAnySigningId, _kSandboxAppBundlePlatformTeamId, 
+                       _rootless_allows_task_for_pid, _rootless_apply, _rootless_apply_internal, 
+                       _rootless_apply_relative, _rootless_check_datavault_flag, 
+                       _rootless_check_restricted_flag, _rootless_check_trusted, 
+                       _rootless_check_trusted_class, _rootless_check_trusted_fd, 
+                       _rootless_convert_to_datavault, _rootless_manifest_free, _rootless_manifest_parse, 
+                       _rootless_mkdir_datavault, _rootless_mkdir_nounlink, _rootless_mkdir_restricted, 
+                       _rootless_preflight, _rootless_protected_volume, _rootless_register_trusted_storage_class, 
+                       _rootless_remove_datavault_in_favor_of_static_storage_class, 
+                       _rootless_remove_restricted_in_favor_of_static_storage_class, 
+                       _rootless_restricted_environment, _rootless_suspend, _rootless_trusted_by_self_token, 
+                       _rootless_verify_trusted_by_self_token, _sandbox_builtin_query, 
+                       _sandbox_check, _sandbox_check_bulk, _sandbox_check_by_audit_token, 
+                       _sandbox_check_by_reference, _sandbox_check_by_uniqueid, _sandbox_check_message_filter_integer, 
+                       _sandbox_check_message_filter_string, _sandbox_consume_extension, 
+                       _sandbox_consume_fs_extension, _sandbox_consume_mach_extension, 
+                       _sandbox_container_path_for_audit_token, _sandbox_container_path_for_pid, 
+                       _sandbox_enable_root_translation, _sandbox_enable_state_flag, 
+                       _sandbox_extension_consume, _sandbox_extension_issue_file, 
+                       _sandbox_extension_issue_file_to_process, _sandbox_extension_issue_file_to_process_by_pid, 
+                       _sandbox_extension_issue_file_to_self, _sandbox_extension_issue_generic, 
+                       _sandbox_extension_issue_generic_to_process, _sandbox_extension_issue_generic_to_process_by_pid, 
+                       _sandbox_extension_issue_iokit_registry_entry_class, _sandbox_extension_issue_iokit_registry_entry_class_to_process, 
+                       _sandbox_extension_issue_iokit_registry_entry_class_to_process_by_pid, 
+                       _sandbox_extension_issue_iokit_user_client_class, _sandbox_extension_issue_mach, 
+                       _sandbox_extension_issue_mach_to_process, _sandbox_extension_issue_mach_to_process_by_pid, 
+                       _sandbox_extension_issue_posix_ipc, _sandbox_extension_reap, 
+                       _sandbox_extension_release, _sandbox_extension_release_file, 
+                       _sandbox_extension_update_file, _sandbox_free_error, _sandbox_get_container_expected, 
+                       _sandbox_init, _sandbox_init_from_pid, _sandbox_init_with_extensions, 
+                       _sandbox_init_with_parameters, _sandbox_issue_extension, _sandbox_issue_fs_extension, 
+                       _sandbox_issue_fs_rw_extension, _sandbox_issue_mach_extension, 
+                       _sandbox_message_filter_query, _sandbox_message_filter_release, 
+                       _sandbox_message_filter_retain, _sandbox_note, _sandbox_passthrough_access, 
+                       _sandbox_proc_getcontainer, _sandbox_proc_getprofilename, 
+                       _sandbox_query_approval_policy_for_path, _sandbox_query_user_intent_for_process_with_audit_token, 
+                       _sandbox_reference_release, _sandbox_reference_retain_by_audit_token, 
+                       _sandbox_register_app_bundle, _sandbox_register_app_bundle_exception, 
+                       _sandbox_register_app_bundle_package_exception, _sandbox_register_bastion_profile, 
+                       _sandbox_register_sync_root, _sandbox_release_fs_extension, 
+                       _sandbox_requests_integrity_protection_for_preference_domain, 
+                       _sandbox_set_container_path_for_application_group, _sandbox_set_container_path_for_application_group_with_persona, 
+                       _sandbox_set_container_path_for_audit_token, _sandbox_set_container_path_for_signing_id, 
+                       _sandbox_set_container_path_for_signing_id_with_persona, _sandbox_spawnattrs_getcontainer, 
+                       _sandbox_spawnattrs_getprofilename, _sandbox_spawnattrs_init, 
+                       _sandbox_spawnattrs_setcontainer, _sandbox_spawnattrs_setprofilename, 
+                       _sandbox_suspend, _sandbox_unregister_app_bundle, _sandbox_unregister_bastion_profile, 
+                       _sandbox_unsuspend ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           15425DC5-5AEF-3711-A6B1-E3979FBEC662
+  - target:          x86_64-maccatalyst
+    value:           15425DC5-5AEF-3711-A6B1-E3979FBEC662
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           B8D75446-A5A3-3D0C-9C89-B65092333CD2
+  - target:          arm64e-maccatalyst
+    value:           B8D75446-A5A3-3D0C-9C89-B65092333CD2
+install-name:    '/usr/lib/system/libsystem_secinit.dylib'
+current-version: 119.40.2
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ __libsecinit_initializer, _libsecinit_delete_all_data_container_content_for_current_user, 
+                       _libsecinit_fileoperation_save, _libsecinit_fileoperation_set_attributes, 
+                       _libsecinit_fileoperation_symlink ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           CA62E5A0-80F0-3798-B8B6-71088A61F03C
+  - target:          x86_64-maccatalyst
+    value:           CA62E5A0-80F0-3798-B8B6-71088A61F03C
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           DE393954-A39B-305C-BF0D-CF7563473762
+  - target:          arm64e-maccatalyst
+    value:           DE393954-A39B-305C-BF0D-CF7563473762
+install-name:    '/usr/lib/system/libsystem_symptoms.dylib'
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ __symptoms_daemon_fallback_initial_disposition, __symptoms_daemon_fallback_subseq_disposition, 
+                       __symptoms_is_daemon_fallback_blacklisted, _symptom_framework_init, 
+                       _symptom_framework_set_version, _symptom_new, _symptom_send, 
+                       _symptom_send_immediate, _symptom_set_additional_qualifier, 
+                       _symptom_set_qualifier ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           EBFC896A-380B-39AB-949F-06BEADFCDBF8
+  - target:          x86_64-maccatalyst
+    value:           EBFC896A-380B-39AB-949F-06BEADFCDBF8
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           73557AF9-086C-3CB4-9E95-CA1D774CAA41
+  - target:          arm64e-maccatalyst
+    value:           73557AF9-086C-3CB4-9E95-CA1D774CAA41
+install-name:    '/usr/lib/system/libsystem_trace.dylib'
+current-version: 1406.0.15
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ __libtrace_fork_child, __libtrace_init, __os_activity_create, 
+                       __os_activity_current, __os_activity_initiate, __os_activity_initiate_f, 
+                       __os_activity_label_useraction, __os_activity_none, __os_activity_set_breadcrumb, 
+                       __os_activity_start, __os_activity_stream_entry_encode, __os_log_create, 
+                       __os_log_debug, __os_log_debug_impl, __os_log_default, __os_log_disabled, 
+                       __os_log_error, __os_log_error_impl, __os_log_fault, __os_log_fault_impl, 
+                       __os_log_get_nscf_formatter, __os_log_impl, __os_log_internal, 
+                       __os_log_pack_fill, __os_log_pack_size, __os_log_preferences_compute, 
+                       __os_log_preferences_copy_cache, __os_log_preferences_load, 
+                       __os_log_preferences_load_sysprefs, __os_log_release, __os_log_send_and_compose_impl, 
+                       __os_log_set_nscf_formatter, __os_signpost_emit_impl, __os_signpost_emit_unreliably_with_name_impl, 
+                       __os_signpost_emit_with_name_impl, __os_signpost_pack_fill, 
+                       __os_signpost_pack_send, __os_state_request_for_pidlist, __os_trace_app_cryptex_sysprefsdir_path, 
+                       __os_trace_atm_diagnostic_config, __os_trace_basesystem_storage_available, 
+                       __os_trace_calloc, __os_trace_commpage_compute, __os_trace_fdscandir_b, 
+                       __os_trace_get_boot_uuid, __os_trace_get_image_info, __os_trace_get_mode_for_pid, 
+                       __os_trace_get_times_now, __os_trace_getxattr_at, __os_trace_intprefsdir_path, 
+                       __os_trace_is_development_build, __os_trace_lazy_init_completed_4libxpc, 
+                       __os_trace_log_simple, __os_trace_macho_for_each_slice, __os_trace_malloc, 
+                       __os_trace_memdup, __os_trace_mmap, __os_trace_mmap_at, __os_trace_mmap_offset, 
+                       __os_trace_mode_match_4tests, __os_trace_os_cryptex_sysprefsdir_path, 
+                       __os_trace_prefs_latest_version_4tests, __os_trace_prefsdir_path, 
+                       __os_trace_read_file_at, __os_trace_read_plist_at, __os_trace_realloc, 
+                       __os_trace_scandir_free_namelist, __os_trace_sect_names, __os_trace_set_diagnostic_flags, 
+                       __os_trace_set_mode_for_pid, __os_trace_strdup, __os_trace_sysprefsdir_path, 
+                       __os_trace_update_with_datavolume_4launchd, __os_trace_with_buffer, 
+                       __os_trace_write, __os_trace_writev, __os_trace_zalloc, _os_activity_apply, 
+                       _os_activity_apply_f, _os_activity_diagnostic_for_pid, _os_activity_end, 
+                       _os_activity_for_task_thread, _os_activity_for_thread, _os_activity_get_active, 
+                       _os_activity_get_identifier, _os_activity_iterate_activities, 
+                       _os_activity_iterate_breadcrumbs, _os_activity_iterate_messages, 
+                       _os_activity_iterate_processes, _os_activity_messages_for_thread, 
+                       _os_activity_scope_enter, _os_activity_scope_leave, _os_log_backtrace_copy_description, 
+                       _os_log_backtrace_copy_serialized_buffer, _os_log_backtrace_create_from_buffer, 
+                       _os_log_backtrace_create_from_current, _os_log_backtrace_create_from_pcs, 
+                       _os_log_backtrace_create_from_return_address, _os_log_backtrace_destroy, 
+                       _os_log_backtrace_get_frames, _os_log_backtrace_get_length, 
+                       _os_log_backtrace_print_to_blob, _os_log_backtrace_serialize_to_blob, 
+                       _os_log_create, _os_log_errors_count, _os_log_fault_default_callback, 
+                       _os_log_faults_count, _os_log_fmt_compose, _os_log_fmt_convert_trace, 
+                       _os_log_fmt_extract_pubdata, _os_log_fmt_get_plugin, _os_log_get_type, 
+                       _os_log_is_debug_enabled, _os_log_is_enabled, _os_log_pack_compose, 
+                       _os_log_pack_send, _os_log_pack_send_and_compose, _os_log_set_client_type, 
+                       _os_log_set_enabled, _os_log_set_fault_callback, _os_log_shim_enabled, 
+                       _os_log_shim_legacy_logging_enabled, _os_log_shim_with_CFString, 
+                       _os_log_type_enabled, _os_log_with_args, _os_signpost_enabled, 
+                       _os_signpost_id_generate, _os_signpost_id_make_with_pointer, 
+                       _os_signpost_set_introspection_hook_4Perf, _os_state_add_handler, 
+                       _os_state_remove_handler, _os_trace_debug_enabled, _os_trace_get_mode, 
+                       _os_trace_get_type, _os_trace_info_enabled, _os_trace_set_mode ]
+    objc-classes:    [ OS_os_log ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           31C10303-6B57-3219-8DEF-ED784DCC67BA
+  - target:          x86_64-maccatalyst
+    value:           31C10303-6B57-3219-8DEF-ED784DCC67BA
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           60F56A64-C75D-3E87-B275-E1FB9D078C5E
+  - target:          arm64e-maccatalyst
+    value:           60F56A64-C75D-3E87-B275-E1FB9D078C5E
+install-name:    '/usr/lib/system/libunwind.dylib'
+current-version: 202.100
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
+    symbols:         [ '$ld$hide$os10.4$__Unwind_Backtrace', '$ld$hide$os10.4$__Unwind_DeleteException', 
+                       '$ld$hide$os10.4$__Unwind_FindEnclosingFunction', '$ld$hide$os10.4$__Unwind_Find_FDE', 
+                       '$ld$hide$os10.4$__Unwind_ForcedUnwind', '$ld$hide$os10.4$__Unwind_GetCFA', 
+                       '$ld$hide$os10.4$__Unwind_GetDataRelBase', '$ld$hide$os10.4$__Unwind_GetGR', 
+                       '$ld$hide$os10.4$__Unwind_GetIP', '$ld$hide$os10.4$__Unwind_GetIPInfo', 
+                       '$ld$hide$os10.4$__Unwind_GetLanguageSpecificData', '$ld$hide$os10.4$__Unwind_GetRegionStart', 
+                       '$ld$hide$os10.4$__Unwind_GetTextRelBase', '$ld$hide$os10.4$__Unwind_RaiseException', 
+                       '$ld$hide$os10.4$__Unwind_Resume', '$ld$hide$os10.4$__Unwind_Resume_or_Rethrow', 
+                       '$ld$hide$os10.4$__Unwind_SetGR', '$ld$hide$os10.4$__Unwind_SetIP', 
+                       '$ld$hide$os10.4$___deregister_frame', '$ld$hide$os10.4$___deregister_frame_info', 
+                       '$ld$hide$os10.4$___deregister_frame_info_bases', '$ld$hide$os10.4$___register_frame', 
+                       '$ld$hide$os10.4$___register_frame_info', '$ld$hide$os10.4$___register_frame_info_bases', 
+                       '$ld$hide$os10.4$___register_frame_info_table', '$ld$hide$os10.4$___register_frame_info_table_bases', 
+                       '$ld$hide$os10.4$___register_frame_table', '$ld$hide$os10.5$__Unwind_Backtrace', 
+                       '$ld$hide$os10.5$__Unwind_DeleteException', '$ld$hide$os10.5$__Unwind_FindEnclosingFunction', 
+                       '$ld$hide$os10.5$__Unwind_Find_FDE', '$ld$hide$os10.5$__Unwind_ForcedUnwind', 
+                       '$ld$hide$os10.5$__Unwind_GetCFA', '$ld$hide$os10.5$__Unwind_GetDataRelBase', 
+                       '$ld$hide$os10.5$__Unwind_GetGR', '$ld$hide$os10.5$__Unwind_GetIP', 
+                       '$ld$hide$os10.5$__Unwind_GetIPInfo', '$ld$hide$os10.5$__Unwind_GetLanguageSpecificData', 
+                       '$ld$hide$os10.5$__Unwind_GetRegionStart', '$ld$hide$os10.5$__Unwind_GetTextRelBase', 
+                       '$ld$hide$os10.5$__Unwind_RaiseException', '$ld$hide$os10.5$__Unwind_Resume', 
+                       '$ld$hide$os10.5$__Unwind_Resume_or_Rethrow', '$ld$hide$os10.5$__Unwind_SetGR', 
+                       '$ld$hide$os10.5$__Unwind_SetIP', '$ld$hide$os10.5$___deregister_frame', 
+                       '$ld$hide$os10.5$___deregister_frame_info', '$ld$hide$os10.5$___deregister_frame_info_bases', 
+                       '$ld$hide$os10.5$___register_frame', '$ld$hide$os10.5$___register_frame_info', 
+                       '$ld$hide$os10.5$___register_frame_info_bases', '$ld$hide$os10.5$___register_frame_info_table', 
+                       '$ld$hide$os10.5$___register_frame_info_table_bases', '$ld$hide$os10.5$___register_frame_table', 
+                       '$ld$hide$os10.6$___deregister_frame_info', '$ld$hide$os10.6$___deregister_frame_info_bases', 
+                       '$ld$hide$os10.6$___register_frame_info', '$ld$hide$os10.6$___register_frame_info_bases', 
+                       '$ld$hide$os10.6$___register_frame_info_table', '$ld$hide$os10.6$___register_frame_info_table_bases', 
+                       '$ld$hide$os10.6$___register_frame_table', ___deregister_frame_info, 
+                       ___deregister_frame_info_bases, ___register_frame_info, ___register_frame_info_bases, 
+                       ___register_frame_info_table, ___register_frame_info_table_bases, 
+                       ___register_frame_table ]
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ __Unwind_Backtrace, __Unwind_DeleteException, __Unwind_FindEnclosingFunction, 
+                       __Unwind_Find_FDE, __Unwind_ForcedUnwind, __Unwind_GetCFA, 
+                       __Unwind_GetDataRelBase, __Unwind_GetGR, __Unwind_GetIP, __Unwind_GetIPInfo, 
+                       __Unwind_GetLanguageSpecificData, __Unwind_GetRegionStart, 
+                       __Unwind_GetTextRelBase, __Unwind_RaiseException, __Unwind_Resume, 
+                       __Unwind_Resume_or_Rethrow, __Unwind_SetGR, __Unwind_SetIP, 
+                       ___deregister_frame, ___register_frame, ___unw_add_dynamic_fde, 
+                       ___unw_remove_dynamic_fde, _unw_get_fpreg, _unw_get_proc_info, 
+                       _unw_get_proc_name, _unw_get_reg, _unw_getcontext, _unw_init_local, 
+                       _unw_is_fpreg, _unw_is_signal_frame, _unw_iterate_dwarf_unwind_cache, 
+                       _unw_local_addr_space, _unw_regname, _unw_resume, _unw_set_fpreg, 
+                       _unw_set_reg, _unw_step ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                   arm64e-macos, arm64e-maccatalyst ]
+uuids:
+  - target:          x86_64-macos
+    value:           38124BDF-4424-32BF-A60B-B4E96BC0EF70
+  - target:          x86_64-maccatalyst
+    value:           38124BDF-4424-32BF-A60B-B4E96BC0EF70
+  - target:          arm64-macos
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64-maccatalyst
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          arm64e-macos
+    value:           44992A1E-D222-3D40-841D-E2CF9E26F67E
+  - target:          arm64e-maccatalyst
+    value:           44992A1E-D222-3D40-841D-E2CF9E26F67E
+install-name:    '/usr/lib/system/libxpc.dylib'
+current-version: 2462.41.2
+parent-umbrella:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    umbrella:        System
+exports:
+  - targets:         [ x86_64-macos, x86_64-maccatalyst, arm64-macos, arm64-maccatalyst, 
+                       arm64e-macos, arm64e-maccatalyst ]
+    symbols:         [ _XPC_ACTIVITY_ALLOW_BATTERY, _XPC_ACTIVITY_APP_REFRESH, _XPC_ACTIVITY_CHECK_IN, 
+                       _XPC_ACTIVITY_COMMUNICATES_WITH_PAIRED_DEVICE, _XPC_ACTIVITY_CPU_INTENSIVE, 
+                       _XPC_ACTIVITY_DELAY, _XPC_ACTIVITY_DESIRED_MOTION_STATE, _XPC_ACTIVITY_DISK_INTENSIVE, 
+                       _XPC_ACTIVITY_DO_IT_LATER, _XPC_ACTIVITY_DUET_ACTIVITY_SCHEDULER_DATA, 
+                       _XPC_ACTIVITY_DUET_ATTRIBUTE_COST, _XPC_ACTIVITY_DUET_ATTRIBUTE_NAME, 
+                       _XPC_ACTIVITY_DUET_ATTRIBUTE_VALUE, _XPC_ACTIVITY_DUET_RELATED_APPLICATIONS, 
+                       _XPC_ACTIVITY_EXCLUSIVE, _XPC_ACTIVITY_EXPECTED_DURATION, 
+                       _XPC_ACTIVITY_GRACE_PERIOD, _XPC_ACTIVITY_GROUP_CONCURRENCY_LIMIT, 
+                       _XPC_ACTIVITY_GROUP_NAME, _XPC_ACTIVITY_INTERVAL, _XPC_ACTIVITY_INTERVAL_15_MIN, 
+                       _XPC_ACTIVITY_INTERVAL_1_DAY, _XPC_ACTIVITY_INTERVAL_1_HOUR, 
+                       _XPC_ACTIVITY_INTERVAL_1_MIN, _XPC_ACTIVITY_INTERVAL_30_MIN, 
+                       _XPC_ACTIVITY_INTERVAL_4_HOURS, _XPC_ACTIVITY_INTERVAL_5_MIN, 
+                       _XPC_ACTIVITY_INTERVAL_7_DAYS, _XPC_ACTIVITY_INTERVAL_8_HOURS, 
+                       _XPC_ACTIVITY_INVOLVED_PROCESSES, _XPC_ACTIVITY_MAY_REBOOT_DEVICE, 
+                       _XPC_ACTIVITY_MEMORY_INTENSIVE, _XPC_ACTIVITY_MOTION_STATE_AUTOMOTIVE, 
+                       _XPC_ACTIVITY_MOTION_STATE_AUTOMOTIVE_MOVING, _XPC_ACTIVITY_MOTION_STATE_AUTOMOTIVE_STATIONARY, 
+                       _XPC_ACTIVITY_MOTION_STATE_CYCLING, _XPC_ACTIVITY_MOTION_STATE_RUNNING, 
+                       _XPC_ACTIVITY_MOTION_STATE_STATIONARY, _XPC_ACTIVITY_MOTION_STATE_WALKING, 
+                       _XPC_ACTIVITY_NETWORK_DOWNLOAD_SIZE, _XPC_ACTIVITY_NETWORK_TRANSFER_BIDIRECTIONAL, 
+                       _XPC_ACTIVITY_NETWORK_TRANSFER_DIRECTION, _XPC_ACTIVITY_NETWORK_TRANSFER_DIRECTION_DOWNLOAD, 
+                       _XPC_ACTIVITY_NETWORK_TRANSFER_DIRECTION_UPLOAD, _XPC_ACTIVITY_NETWORK_TRANSFER_ENDPOINT, 
+                       _XPC_ACTIVITY_NETWORK_TRANSFER_PARAMETERS, _XPC_ACTIVITY_NETWORK_TRANSFER_SIZE, 
+                       _XPC_ACTIVITY_NETWORK_UPLOAD_SIZE, _XPC_ACTIVITY_POST_INSTALL, 
+                       _XPC_ACTIVITY_POWER_NAP, _XPC_ACTIVITY_PREVENT_DEVICE_SLEEP, 
+                       _XPC_ACTIVITY_PRIORITY, _XPC_ACTIVITY_PRIORITY_MAINTENANCE, 
+                       _XPC_ACTIVITY_PRIORITY_UTILITY, _XPC_ACTIVITY_RANDOM_INITIAL_DELAY, 
+                       _XPC_ACTIVITY_REPEATING, _XPC_ACTIVITY_REPLY_ENDPOINT, _XPC_ACTIVITY_REQUIRES_BUDDY_COMPLETE, 
+                       _XPC_ACTIVITY_REQUIRES_CLASS_A, _XPC_ACTIVITY_REQUIRES_CLASS_B, 
+                       _XPC_ACTIVITY_REQUIRES_CLASS_C, _XPC_ACTIVITY_REQUIRE_BATTERY_LEVEL, 
+                       _XPC_ACTIVITY_REQUIRE_HDD_SPINNING, _XPC_ACTIVITY_REQUIRE_INEXPENSIVE_NETWORK_CONNECTIVITY, 
+                       _XPC_ACTIVITY_REQUIRE_NETWORK_CONNECTIVITY, _XPC_ACTIVITY_REQUIRE_SCREEN_SLEEP, 
+                       _XPC_ACTIVITY_REQUIRE_SIGNIFICANT_USER_INACTIVITY, _XPC_ACTIVITY_RUN_WHEN_APP_FOREGROUNDED, 
+                       _XPC_ACTIVITY_SEQUENCE_NUMBER, _XPC_ACTIVITY_SHOULD_WAKE_DEVICE, 
+                       _XPC_ACTIVITY_USER_REQUESTED_BACKUP_TASK, _XPC_ACTIVITY_USES_DATA_BUDGETING, 
+                       _XPC_ACTIVITY_USES_DUET_POWER_BUDGETING, _XPC_COALITION_INFO_KEY_BUNDLE_IDENTIFIER, 
+                       _XPC_COALITION_INFO_KEY_CID, _XPC_COALITION_INFO_KEY_NAME, 
+                       _XPC_COALITION_INFO_KEY_RESOURCE_USAGE_BLOB, __availability_version_check, 
+                       __launch_job_routine, __launch_job_routine_async, __launch_msg2, 
+                       __launch_server_test_routine, __launch_service_stats_copy_4ppse_impl, 
+                       __libxpc_initializer, __spawn_via_launchd, __system_ios_support_version_copy_string_sysctl, 
+                       __system_version_copy_string_plist, __system_version_copy_string_sysctl, 
+                       __system_version_fallback, __system_version_parse_string, 
+                       __vproc_get_last_exit_status, __vproc_grab_subset, __vproc_kickstart_by_label, 
+                       __vproc_log, __vproc_log_error, __vproc_logv, __vproc_pid_is_managed, 
+                       __vproc_post_fork_ping, __vproc_send_signal_by_label, __vproc_set_global_on_demand, 
+                       __vproc_standby_begin, __vproc_standby_count, __vproc_standby_end, 
+                       __vproc_standby_timeout, __vproc_transaction_begin, __vproc_transaction_count, 
+                       __vproc_transaction_count_for_pid, __vproc_transaction_end, 
+                       __vproc_transaction_set_clean_callback, __vproc_transaction_try_exit, 
+                       __vproc_transactions_enable, __vprocmgr_detach_from_console, 
+                       __vprocmgr_getsocket, __vprocmgr_init, __vprocmgr_log_drain, 
+                       __vprocmgr_log_forward, __vprocmgr_move_subset_to_user, __vprocmgr_switch_to_session, 
+                       __xpc_bool_create_distinct, __xpc_bool_false, __xpc_bool_set_value, 
+                       __xpc_bool_true, __xpc_connection_get_parent_4test, __xpc_connection_get_recvp_4test, 
+                       __xpc_connection_set_event_handler_f, __xpc_data_set_value, 
+                       __xpc_dictionary_create_reply_with_port, __xpc_dictionary_extract_mach_send, 
+                       __xpc_dictionary_extract_reply_msg_id, __xpc_dictionary_extract_reply_port, 
+                       __xpc_dictionary_get_reply_msg_id, __xpc_dictionary_set_remote_connection, 
+                       __xpc_dictionary_set_reply_msg_id, __xpc_domain_routine, __xpc_double_set_value, 
+                       __xpc_error_connection_interrupted, __xpc_error_connection_invalid, 
+                       __xpc_error_key_description, __xpc_error_peer_code_signing_requirement, 
+                       __xpc_error_termination_imminent, __xpc_event_key_name, __xpc_event_key_stream_name, 
+                       __xpc_fd_get_port, __xpc_int64_set_value, __xpc_payload_create_from_mach_msg, 
+                       __xpc_pipe_handle_mig, __xpc_pipe_interface_routine, __xpc_pipe_interface_routine_async, 
+                       __xpc_pipe_interface_simpleroutine, __xpc_runtime_get_entitlements_data, 
+                       __xpc_runtime_get_self_entitlements, __xpc_runtime_is_app_sandboxed, 
+                       __xpc_service_last_xref_cancel, __xpc_service_routine, __xpc_shmem_get_mach_port, 
+                       __xpc_spawnattr_binprefs_pack, __xpc_spawnattr_binprefs_size, 
+                       __xpc_spawnattr_binprefs_unpack, __xpc_spawnattr_pack_bytes, 
+                       __xpc_spawnattr_pack_string, __xpc_spawnattr_pack_string_fragment, 
+                       __xpc_spawnattr_unpack_bytes, __xpc_spawnattr_unpack_string, 
+                       __xpc_spawnattr_unpack_strings, __xpc_string_set_value, __xpc_type_activity, 
+                       __xpc_type_array, __xpc_type_base, __xpc_type_bool, __xpc_type_bundle, 
+                       __xpc_type_connection, __xpc_type_data, __xpc_type_date, __xpc_type_dictionary, 
+                       __xpc_type_double, __xpc_type_endpoint, __xpc_type_error, 
+                       __xpc_type_fd, __xpc_type_file_transfer, __xpc_type_int64, 
+                       __xpc_type_mach_recv, __xpc_type_mach_send, __xpc_type_mach_send_once, 
+                       __xpc_type_null, __xpc_type_pipe, __xpc_type_pointer, __xpc_type_rich_error, 
+                       __xpc_type_serializer, __xpc_type_service, __xpc_type_service_instance, 
+                       __xpc_type_session, __xpc_type_shmem, __xpc_type_string, __xpc_type_uint64, 
+                       __xpc_type_uuid, __xpc_vtables, _bootstrap_check_in, _bootstrap_check_in2, 
+                       _bootstrap_check_in3, _bootstrap_create_server, _bootstrap_create_service, 
+                       _bootstrap_get_root, _bootstrap_info, _bootstrap_init, _bootstrap_look_up, 
+                       _bootstrap_look_up2, _bootstrap_look_up3, _bootstrap_look_up_per_user, 
+                       _bootstrap_lookup_children, _bootstrap_parent, _bootstrap_register, 
+                       _bootstrap_register2, _bootstrap_status, _bootstrap_strerror, 
+                       _bootstrap_subset, _bootstrap_unprivileged, _create_and_switch_to_per_session_launchd, 
+                       _launch_activate_socket, _launch_active_user_switch, _launch_add_external_service, 
+                       _launch_bootout_user_service_4coresim, _launch_copy_busy_extension_instances, 
+                       _launch_copy_endpoints_properties_for_pid, _launch_copy_extension_properties, 
+                       _launch_copy_extension_properties_for_pid, _launch_copy_properties_for_pid_4assertiond, 
+                       _launch_create_persona, _launch_cryptex_terminate, _launch_data_alloc, 
+                       _launch_data_array_get_count, _launch_data_array_get_index, 
+                       _launch_data_array_set_index, _launch_data_copy, _launch_data_dict_get_count, 
+                       _launch_data_dict_insert, _launch_data_dict_iterate, _launch_data_dict_lookup, 
+                       _launch_data_dict_remove, _launch_data_free, _launch_data_get_bool, 
+                       _launch_data_get_errno, _launch_data_get_fd, _launch_data_get_integer, 
+                       _launch_data_get_machport, _launch_data_get_opaque, _launch_data_get_opaque_size, 
+                       _launch_data_get_real, _launch_data_get_string, _launch_data_get_type, 
+                       _launch_data_new_bool, _launch_data_new_errno, _launch_data_new_fd, 
+                       _launch_data_new_integer, _launch_data_new_machport, _launch_data_new_opaque, 
+                       _launch_data_new_real, _launch_data_new_string, _launch_data_pack, 
+                       _launch_data_set_bool, _launch_data_set_errno, _launch_data_set_fd, 
+                       _launch_data_set_integer, _launch_data_set_machport, _launch_data_set_opaque, 
+                       _launch_data_set_real, _launch_data_set_string, _launch_data_unpack, 
+                       _launch_destroy_persona, _launch_disable_directory, _launch_enable_directory, 
+                       _launch_extension_check_in_live_4UIKit, _launch_extension_property_bundle_id, 
+                       _launch_extension_property_host_bundle_id, _launch_extension_property_host_pid, 
+                       _launch_extension_property_path, _launch_extension_property_pid, 
+                       _launch_extension_property_version, _launch_extension_property_xpc_bundle, 
+                       _launch_get_fd, _launch_get_service_enabled, _launch_get_system_service_enabled, 
+                       _launch_load_mounted_jetsam_properties, _launch_msg, _launch_path_for_user_service_4coresim, 
+                       _launch_perfcheck_property_endpoint_active, _launch_perfcheck_property_endpoint_event, 
+                       _launch_perfcheck_property_endpoint_name, _launch_perfcheck_property_endpoint_needs_activation, 
+                       _launch_perfcheck_property_endpoints, _launch_remove_external_service, 
+                       _launch_service_instance_copy_uuids, _launch_service_instance_create, 
+                       _launch_service_instance_remove, _launch_service_stats_disable_4ppse, 
+                       _launch_service_stats_enable_4ppse, _launch_service_stats_is_enabled_4ppse, 
+                       _launch_set_service_enabled, _launch_set_system_service_enabled, 
+                       _launch_socket_service_check_in, _launch_version_for_user_service_4coresim, 
+                       _launch_wait, _launchd_close, _launchd_fdopen, _launchd_getfd, 
+                       _launchd_msg_recv, _launchd_msg_send, _load_launchd_jobs_at_loginwindow_prompt, 
+                       _mpm_uncork_fork, _mpm_wait, _os_system_version_get_current_version, 
+                       _os_system_version_get_ios_support_version, _os_system_version_sim_get_current_host_version, 
+                       _os_transaction_copy_description, _os_transaction_create, 
+                       _os_transaction_get_description, _os_transaction_get_timestamp, 
+                       _os_transaction_needs_more_time, _place_hold_on_real_loginwindow, 
+                       _reboot2, _reboot3, _vproc_release, _vproc_retain, _vproc_standby_begin, 
+                       _vproc_standby_end, _vproc_swap_complex, _vproc_swap_integer, 
+                       _vproc_swap_string, _vproc_transaction_begin, _vproc_transaction_end, 
+                       _vprocmgr_lookup_vproc, _xpc_activity_add_eligibility_changed_handler, 
+                       _xpc_activity_copy_criteria, _xpc_activity_copy_dispatch_queue, 
+                       _xpc_activity_copy_identifier, _xpc_activity_debug, _xpc_activity_defer_until_network_change, 
+                       _xpc_activity_defer_until_percentage, _xpc_activity_get_percentage, 
+                       _xpc_activity_get_state, _xpc_activity_list, _xpc_activity_register, 
+                       _xpc_activity_remove_eligibility_changed_handler, _xpc_activity_run, 
+                       _xpc_activity_set_completion_status, _xpc_activity_set_criteria, 
+                       _xpc_activity_set_network_threshold, _xpc_activity_set_state, 
+                       _xpc_activity_should_be_data_budgeted, _xpc_activity_should_defer, 
+                       _xpc_activity_unregister, _xpc_add_bundle, _xpc_add_bundles_for_domain, 
+                       _xpc_array_append_value, _xpc_array_apply, _xpc_array_apply_f, 
+                       _xpc_array_copy_mach_send, _xpc_array_create, _xpc_array_create_connection, 
+                       _xpc_array_create_empty, _xpc_array_dup_fd, _xpc_array_get_array, 
+                       _xpc_array_get_bool, _xpc_array_get_count, _xpc_array_get_data, 
+                       _xpc_array_get_date, _xpc_array_get_dictionary, _xpc_array_get_double, 
+                       _xpc_array_get_int64, _xpc_array_get_pointer, _xpc_array_get_string, 
+                       _xpc_array_get_uint64, _xpc_array_get_uuid, _xpc_array_get_value, 
+                       _xpc_array_set_bool, _xpc_array_set_connection, _xpc_array_set_data, 
+                       _xpc_array_set_date, _xpc_array_set_double, _xpc_array_set_fd, 
+                       _xpc_array_set_int64, _xpc_array_set_mach_send, _xpc_array_set_pointer, 
+                       _xpc_array_set_string, _xpc_array_set_uint64, _xpc_array_set_uuid, 
+                       _xpc_array_set_value, _xpc_atfork_child, _xpc_atfork_parent, 
+                       _xpc_atfork_prepare, _xpc_binprefs_add, _xpc_binprefs_alloc, 
+                       _xpc_binprefs_copy, _xpc_binprefs_copy_description, _xpc_binprefs_count, 
+                       _xpc_binprefs_cpu_subtype, _xpc_binprefs_cpu_type, _xpc_binprefs_equal, 
+                       _xpc_binprefs_init, _xpc_binprefs_is_noop, _xpc_binprefs_set_psattr, 
+                       _xpc_bool_create, _xpc_bool_get_value, _xpc_bundle_copy_info_dictionary, 
+                       _xpc_bundle_copy_normalized_cryptex_path, _xpc_bundle_copy_resource_path, 
+                       _xpc_bundle_copy_services, _xpc_bundle_create, _xpc_bundle_create_from_origin, 
+                       _xpc_bundle_create_main, _xpc_bundle_get_error, _xpc_bundle_get_executable_path, 
+                       _xpc_bundle_get_info_dictionary, _xpc_bundle_get_path, _xpc_bundle_get_property, 
+                       _xpc_bundle_get_xpcservice_dictionary, _xpc_bundle_populate, 
+                       _xpc_bundle_resolve, _xpc_bundle_resolve_on_queue, _xpc_bundle_resolve_sync, 
+                       _xpc_coalition_copy_info, _xpc_coalition_history_pipe_async, 
+                       _xpc_connection_activate, _xpc_connection_cancel, _xpc_connection_copy_bundle_id, 
+                       _xpc_connection_copy_entitlement_value, _xpc_connection_copy_invalidation_reason, 
+                       _xpc_connection_create, _xpc_connection_create_from_endpoint, 
+                       _xpc_connection_create_listener, _xpc_connection_create_mach_service, 
+                       _xpc_connection_enable_sim2host_4sim, _xpc_connection_enable_termination_imminent_event, 
+                       _xpc_connection_get_asid, _xpc_connection_get_audit_token, 
+                       _xpc_connection_get_bs_type, _xpc_connection_get_context, 
+                       _xpc_connection_get_egid, _xpc_connection_get_euid, _xpc_connection_get_filter_policy_id_4test, 
+                       _xpc_connection_get_instance, _xpc_connection_get_name, _xpc_connection_get_peer_instance, 
+                       _xpc_connection_get_pid, _xpc_connection_is_extension, _xpc_connection_kill, 
+                       _xpc_connection_resume, _xpc_connection_send_barrier, _xpc_connection_send_message, 
+                       _xpc_connection_send_message_with_reply, _xpc_connection_send_message_with_reply_sync, 
+                       _xpc_connection_send_notification, _xpc_connection_set_bootstrap, 
+                       _xpc_connection_set_bs_type, _xpc_connection_set_context, 
+                       _xpc_connection_set_event_channel, _xpc_connection_set_event_handler, 
+                       _xpc_connection_set_finalizer_f, _xpc_connection_set_instance, 
+                       _xpc_connection_set_instance_binpref, _xpc_connection_set_legacy, 
+                       _xpc_connection_set_non_launching, _xpc_connection_set_oneshot_instance, 
+                       _xpc_connection_set_peer_code_signing_requirement, _xpc_connection_set_privileged, 
+                       _xpc_connection_set_qos_class_fallback, _xpc_connection_set_qos_class_floor, 
+                       _xpc_connection_set_target_queue, _xpc_connection_set_target_uid, 
+                       _xpc_connection_set_target_user_session_uid, _xpc_connection_suspend, 
+                       _xpc_copy, _xpc_copy_bootstrap, _xpc_copy_clean_description, 
+                       _xpc_copy_code_signing_identity_for_token, _xpc_copy_debug_description, 
+                       _xpc_copy_description, _xpc_copy_domain, _xpc_copy_entitlement_for_self, 
+                       _xpc_copy_entitlement_for_token, _xpc_copy_entitlements_data_for_token, 
+                       _xpc_copy_entitlements_for_pid, _xpc_copy_entitlements_for_self, 
+                       _xpc_copy_event, _xpc_copy_event_entitlements, _xpc_copy_short_description, 
+                       _xpc_create_from_ce_der, _xpc_create_from_ce_der_with_key, 
+                       _xpc_create_from_plist, _xpc_create_from_plist_descriptor, 
+                       _xpc_create_from_serialization, _xpc_create_from_serialization_with_ool, 
+                       _xpc_create_reply_with_format, _xpc_create_reply_with_format_and_arguments, 
+                       _xpc_create_with_format, _xpc_create_with_format_and_arguments, 
+                       _xpc_data_create, _xpc_data_create_with_dispatch_data, _xpc_data_get_bytes, 
+                       _xpc_data_get_bytes_ptr, _xpc_data_get_bytes_ptr_and_length, 
+                       _xpc_data_get_inline_max, _xpc_data_get_length, _xpc_date_create, 
+                       _xpc_date_create_absolute, _xpc_date_create_from_current, 
+                       _xpc_date_get_value, _xpc_date_get_value_absolute, _xpc_date_is_int64_range, 
+                       _xpc_dictionary_apply, _xpc_dictionary_apply_f, _xpc_dictionary_copy_basic_description, 
+                       _xpc_dictionary_copy_mach_send, _xpc_dictionary_create, _xpc_dictionary_create_connection, 
+                       _xpc_dictionary_create_empty, _xpc_dictionary_create_reply, 
+                       _xpc_dictionary_dup_fd, _xpc_dictionary_expects_reply, _xpc_dictionary_extract_mach_recv, 
+                       _xpc_dictionary_get_array, _xpc_dictionary_get_audit_token, 
+                       _xpc_dictionary_get_bool, _xpc_dictionary_get_connection, 
+                       _xpc_dictionary_get_count, _xpc_dictionary_get_data, _xpc_dictionary_get_date, 
+                       _xpc_dictionary_get_dictionary, _xpc_dictionary_get_double, 
+                       _xpc_dictionary_get_int64, _xpc_dictionary_get_pointer, _xpc_dictionary_get_remote_connection, 
+                       _xpc_dictionary_get_string, _xpc_dictionary_get_uint64, _xpc_dictionary_get_uuid, 
+                       _xpc_dictionary_get_value, _xpc_dictionary_handoff_reply, 
+                       _xpc_dictionary_handoff_reply_f, _xpc_dictionary_send_reply, 
+                       _xpc_dictionary_set_bool, _xpc_dictionary_set_connection, 
+                       _xpc_dictionary_set_data, _xpc_dictionary_set_date, _xpc_dictionary_set_double, 
+                       _xpc_dictionary_set_fd, _xpc_dictionary_set_int64, _xpc_dictionary_set_mach_recv, 
+                       _xpc_dictionary_set_mach_send, _xpc_dictionary_set_pointer, 
+                       _xpc_dictionary_set_string, _xpc_dictionary_set_uint64, _xpc_dictionary_set_uuid, 
+                       _xpc_dictionary_set_value, _xpc_double_create, _xpc_double_get_value, 
+                       _xpc_endpoint_compare, _xpc_endpoint_copy_listener_port_4sim, 
+                       _xpc_endpoint_create, _xpc_endpoint_create_bs_named, _xpc_endpoint_create_mach_port_4sim, 
+                       _xpc_endpoint_get_bs_job_handle, _xpc_equal, _xpc_event_publisher_activate, 
+                       _xpc_event_publisher_copy_event, _xpc_event_publisher_create, 
+                       _xpc_event_publisher_fire, _xpc_event_publisher_fire_noboost, 
+                       _xpc_event_publisher_fire_with_reply, _xpc_event_publisher_fire_with_reply_sync, 
+                       _xpc_event_publisher_get_subscriber_asid, _xpc_event_publisher_set_error_handler, 
+                       _xpc_event_publisher_set_event, _xpc_event_publisher_set_handler, 
+                       _xpc_event_publisher_set_initial_load_completed_handler_4remoted, 
+                       _xpc_event_publisher_set_subscriber_keepalive, _xpc_event_stream_check_in, 
+                       _xpc_event_stream_check_in2, _xpc_exit_reason_get_label, _xpc_extension_type_init, 
+                       _xpc_fd_create, _xpc_fd_dup, _xpc_file_transfer_cancel, _xpc_file_transfer_copy_io, 
+                       _xpc_file_transfer_create_with_fd, _xpc_file_transfer_create_with_path, 
+                       _xpc_file_transfer_get_size, _xpc_file_transfer_get_transfer_id, 
+                       _xpc_file_transfer_send_finished, _xpc_file_transfer_set_transport_writing_callbacks, 
+                       _xpc_file_transfer_write_finished, _xpc_file_transfer_write_to_fd, 
+                       _xpc_file_transfer_write_to_path, _xpc_generate_audit_token, 
+                       _xpc_get_attachment_endpoint, _xpc_get_class4NSXPC, _xpc_get_event_name, 
+                       _xpc_get_instance, _xpc_get_type, _xpc_handle_service, _xpc_handle_subservice, 
+                       _xpc_hash, _xpc_impersonate_user, _xpc_init_services, _xpc_inspect_copy_description, 
+                       _xpc_inspect_copy_description_local, _xpc_inspect_copy_short_description, 
+                       _xpc_inspect_copy_short_description_local, _xpc_install_remote_hooks, 
+                       _xpc_int64_create, _xpc_int64_get_value, _xpc_is_kind_of_xpc_object4NSXPC, 
+                       _xpc_mach_recv_create, _xpc_mach_recv_extract_right, _xpc_mach_send_copy_right, 
+                       _xpc_mach_send_create, _xpc_mach_send_create_with_disposition, 
+                       _xpc_mach_send_get_right, _xpc_mach_send_once_create, _xpc_mach_send_once_extract_right, 
+                       _xpc_main, _xpc_make_serialization, _xpc_make_serialization_with_ool, 
+                       _xpc_null_create, _xpc_pipe_create, _xpc_pipe_create_from_port, 
+                       _xpc_pipe_create_reply_from_port, _xpc_pipe_create_with_user_session_uid, 
+                       _xpc_pipe_invalidate, _xpc_pipe_receive, _xpc_pipe_routine, 
+                       _xpc_pipe_routine_async, _xpc_pipe_routine_forward, _xpc_pipe_routine_reply, 
+                       _xpc_pipe_routine_with_flags, _xpc_pipe_simpleroutine, _xpc_pipe_try_receive, 
+                       _xpc_pointer_create, _xpc_pointer_get_value, _xpc_receive_mach_msg, 
+                       _xpc_receive_remote_msg, _xpc_release, _xpc_retain, _xpc_rich_error_can_retry, 
+                       _xpc_rich_error_copy_description, _xpc_service_attach, _xpc_service_attach_with_flags, 
+                       _xpc_service_create, _xpc_service_create_from_specifier, _xpc_service_get_rendezvous_token, 
+                       _xpc_service_instance_dup2, _xpc_service_instance_get_context, 
+                       _xpc_service_instance_get_host_pid, _xpc_service_instance_get_pid, 
+                       _xpc_service_instance_get_type, _xpc_service_instance_is_configurable, 
+                       _xpc_service_instance_run, _xpc_service_instance_set_binpref, 
+                       _xpc_service_instance_set_context, _xpc_service_instance_set_cwd, 
+                       _xpc_service_instance_set_endpoint, _xpc_service_instance_set_environment, 
+                       _xpc_service_instance_set_finalizer_f, _xpc_service_instance_set_jetsam_properties, 
+                       _xpc_service_instance_set_path, _xpc_service_instance_set_start_suspended, 
+                       _xpc_service_kickstart, _xpc_service_kickstart_with_flags, 
+                       _xpc_service_set_attach_handler, _xpc_session_activate, _xpc_session_cancel, 
+                       _xpc_session_copy_description, _xpc_session_create_mach_service, 
+                       _xpc_session_create_xpc_endpoint, _xpc_session_create_xpc_service, 
+                       _xpc_session_send_message, _xpc_session_send_message_with_reply_async, 
+                       _xpc_session_send_message_with_reply_sync, _xpc_session_set_cancel_handler, 
+                       _xpc_session_set_incoming_message_handler, _xpc_session_set_target_user_session_uid, 
+                       _xpc_set_event, _xpc_set_event_state, _xpc_set_event_stream_handler, 
+                       _xpc_set_event_with_flags, _xpc_set_idle_handler, _xpc_shmem_create, 
+                       _xpc_shmem_create_readonly, _xpc_shmem_get_length, _xpc_shmem_map, 
+                       _xpc_strerror, _xpc_string_create, _xpc_string_create_no_copy, 
+                       _xpc_string_create_with_format, _xpc_string_create_with_format_and_arguments, 
+                       _xpc_string_get_length, _xpc_string_get_string_ptr, _xpc_test_symbols_exported, 
+                       _xpc_track_activity, _xpc_transaction_begin, _xpc_transaction_end, 
+                       _xpc_transaction_exit_clean, _xpc_transaction_interrupt_clean_exit, 
+                       _xpc_transactions_enable, _xpc_traverse_serialized_data, _xpc_type_get_name, 
+                       _xpc_uint64_create, _xpc_uint64_get_value, _xpc_user_sessions_enabled, 
+                       _xpc_user_sessions_get_foreground_uid, _xpc_user_sessions_get_session_uid, 
+                       _xpc_uuid_create, _xpc_uuid_get_bytes ]
+    objc-classes:    [ OS_xpc_object ]
+...

From cf2ac99f8461e8d7060c95432889482c0163306a Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Tue, 25 Oct 2022 20:37:09 +0200
Subject: [PATCH 11/70] darwin: remove libSystem.10.tbd

---
 lib/libc/darwin/libSystem.10.tbd | 3061 ------------------------------
 1 file changed, 3061 deletions(-)
 delete mode 100644 lib/libc/darwin/libSystem.10.tbd

diff --git a/lib/libc/darwin/libSystem.10.tbd b/lib/libc/darwin/libSystem.10.tbd
deleted file mode 100644
index e6c3ca3a04..0000000000
--- a/lib/libc/darwin/libSystem.10.tbd
+++ /dev/null
@@ -1,3061 +0,0 @@
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           001B3B7F-D02C-31D3-B961-1ED445D5A266
-  - target:          x86_64-maccatalyst
-    value:           001B3B7F-D02C-31D3-B961-1ED445D5A266
-install-name:    '/usr/lib/libSystem.B.dylib'
-current-version: 1281.100.1
-reexported-libraries:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    libraries:       [ '/usr/lib/system/libcache.dylib', '/usr/lib/system/libcommonCrypto.dylib', 
-                       '/usr/lib/system/libcompiler_rt.dylib', '/usr/lib/system/libcopyfile.dylib', 
-                       '/usr/lib/system/libcorecrypto.dylib', '/usr/lib/system/libdispatch.dylib', 
-                       '/usr/lib/system/libdyld.dylib', '/usr/lib/system/libkeymgr.dylib', 
-                       '/usr/lib/system/liblaunch.dylib', '/usr/lib/system/libmacho.dylib', 
-                       '/usr/lib/system/libquarantine.dylib', '/usr/lib/system/libremovefile.dylib', 
-                       '/usr/lib/system/libsystem_asl.dylib', '/usr/lib/system/libsystem_blocks.dylib', 
-                       '/usr/lib/system/libsystem_c.dylib', '/usr/lib/system/libsystem_configuration.dylib', 
-                       '/usr/lib/system/libsystem_coreservices.dylib', '/usr/lib/system/libsystem_darwin.dylib', 
-                       '/usr/lib/system/libsystem_dnssd.dylib', '/usr/lib/system/libsystem_featureflags.dylib', 
-                       '/usr/lib/system/libsystem_info.dylib', '/usr/lib/system/libsystem_kernel.dylib', 
-                       '/usr/lib/system/libsystem_m.dylib', '/usr/lib/system/libsystem_malloc.dylib', 
-                       '/usr/lib/system/libsystem_networkextension.dylib', '/usr/lib/system/libsystem_notify.dylib', 
-                       '/usr/lib/system/libsystem_platform.dylib', '/usr/lib/system/libsystem_pthread.dylib', 
-                       '/usr/lib/system/libsystem_sandbox.dylib', '/usr/lib/system/libsystem_secinit.dylib', 
-                       '/usr/lib/system/libsystem_symptoms.dylib', '/usr/lib/system/libsystem_trace.dylib', 
-                       '/usr/lib/system/libunwind.dylib', '/usr/lib/system/libxpc.dylib' ]
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ 'R8289209$_close', 'R8289209$_fork', 'R8289209$_fsync', 'R8289209$_getattrlist', 
-                       'R8289209$_getrlimit', 'R8289209$_getxattr', 'R8289209$_open', 
-                       'R8289209$_pthread_attr_destroy', 'R8289209$_pthread_attr_init', 
-                       'R8289209$_pthread_attr_setdetachstate', 'R8289209$_pthread_create', 
-                       'R8289209$_pthread_mutex_lock', 'R8289209$_pthread_mutex_unlock', 
-                       'R8289209$_pthread_self', 'R8289209$_ptrace', 'R8289209$_read', 
-                       'R8289209$_setattrlist', 'R8289209$_setrlimit', 'R8289209$_sigaction', 
-                       'R8289209$_stat', 'R8289209$_sysctl', 'R8289209$_time', 'R8289209$_unlink', 
-                       'R8289209$_write', ___crashreporter_info__, _libSystem_atfork_child, 
-                       _libSystem_atfork_parent, _libSystem_atfork_prepare, _mach_init_routine ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           AF488D13-9E89-35E0-B078-BE37CC5B8586
-  - target:          x86_64-maccatalyst
-    value:           AF488D13-9E89-35E0-B078-BE37CC5B8586
-install-name:    '/usr/lib/system/libcache.dylib'
-current-version: 83
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _cache_create, _cache_destroy, _cache_get, _cache_get_and_retain, 
-                       _cache_get_cost_hint, _cache_get_count_hint, _cache_get_info, 
-                       _cache_get_info_for_key, _cache_get_info_for_keys, _cache_get_minimum_values_hint, 
-                       _cache_get_name, _cache_hash_byte_string, _cache_invoke, _cache_key_hash_cb_cstring, 
-                       _cache_key_hash_cb_integer, _cache_key_is_equal_cb_cstring, 
-                       _cache_key_is_equal_cb_integer, _cache_print, _cache_print_stats, 
-                       _cache_release_cb_free, _cache_release_value, _cache_remove, 
-                       _cache_remove_all, _cache_remove_with_block, _cache_set_and_retain, 
-                       _cache_set_cost_hint, _cache_set_count_hint, _cache_set_minimum_values_hint, 
-                       _cache_set_name, _cache_simulate_memory_warning_event, _cache_value_make_nonpurgeable_cb, 
-                       _cache_value_make_purgeable_cb ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           C7912BE5-993E-3581-B2A0-6AABDC8C5562
-  - target:          x86_64-maccatalyst
-    value:           C7912BE5-993E-3581-B2A0-6AABDC8C5562
-install-name:    '/usr/lib/system/libcommonCrypto.dylib'
-current-version: 60165.120.1
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _CCAESCmac, _CCAESCmacCreate, _CCAESCmacDestroy, _CCAESCmacFinal, 
-                       _CCAESCmacOutputSizeFromContext, _CCAESCmacUpdate, _CCBigNumAdd, 
-                       _CCBigNumAddI, _CCBigNumBitCount, _CCBigNumByteCount, _CCBigNumClear, 
-                       _CCBigNumCompare, _CCBigNumCompareI, _CCBigNumCopy, _CCBigNumCreateRandom, 
-                       _CCBigNumDiv, _CCBigNumDiv2, _CCBigNumFree, _CCBigNumFromData, 
-                       _CCBigNumFromDecimalString, _CCBigNumFromHexString, _CCBigNumGCD, 
-                       _CCBigNumGetI, _CCBigNumInverseMod, _CCBigNumIsNegative, _CCBigNumIsOdd, 
-                       _CCBigNumIsPrime, _CCBigNumIsZero, _CCBigNumLCM, _CCBigNumLeftShift, 
-                       _CCBigNumMod, _CCBigNumModExp, _CCBigNumModI, _CCBigNumMontgomeryNormalization, 
-                       _CCBigNumMontgomeryReduce, _CCBigNumMontgomerySetup, _CCBigNumMul, 
-                       _CCBigNumMulI, _CCBigNumMulMod, _CCBigNumRightShift, _CCBigNumSetI, 
-                       _CCBigNumSetNegative, _CCBigNumSquare, _CCBigNumSquareMod, 
-                       _CCBigNumSub, _CCBigNumSubI, _CCBigNumToData, _CCBigNumToDecimalString, 
-                       _CCBigNumToHexString, _CCBigNumZeroLSBCount, _CCCKGContributorCommit, 
-                       _CCCKGContributorCreate, _CCCKGContributorDestroy, _CCCKGContributorFinish, 
-                       _CCCKGGetCommitmentSize, _CCCKGGetOpeningSize, _CCCKGGetShareSize, 
-                       _CCCKGOwnerCreate, _CCCKGOwnerDestroy, _CCCKGOwnerFinish, 
-                       _CCCKGOwnerGenerateShare, _CCCalibratePBKDF, _CCCreateBigNum, 
-                       _CCCrypt, _CCCryptorAddParameter, _CCCryptorCreate, _CCCryptorCreateFromData, 
-                       _CCCryptorCreateFromDataWithMode, _CCCryptorCreateWithMode, 
-                       _CCCryptorDecryptDataBlock, _CCCryptorEncryptDataBlock, _CCCryptorFinal, 
-                       _CCCryptorGCM, _CCCryptorGCMAddAAD, _CCCryptorGCMAddADD, _CCCryptorGCMAddIV, 
-                       _CCCryptorGCMDecrypt, _CCCryptorGCMEncrypt, _CCCryptorGCMFinal, 
-                       _CCCryptorGCMFinalize, _CCCryptorGCMOneshotDecrypt, _CCCryptorGCMOneshotEncrypt, 
-                       _CCCryptorGCMReset, _CCCryptorGCMSetIV, _CCCryptorGCMaddAAD, 
-                       _CCCryptorGetIV, _CCCryptorGetOutputLength, _CCCryptorGetParameter, 
-                       _CCCryptorRelease, _CCCryptorReset, _CCCryptorReset_binary_compatibility, 
-                       _CCCryptorUpdate, _CCDHComputeKey, _CCDHCreate, _CCDHGenerateKey, 
-                       _CCDHParametersCreateFromData, _CCDHParametersCreateFromPKCS3, 
-                       _CCDHParametersPKCS3Encode, _CCDHParametersPKCS3EncodeLength, 
-                       _CCDHParametersRelease, _CCDHRelease, _CCDeriveKey, _CCDesCBCCksum, 
-                       _CCDesIsWeakKey, _CCDesSetOddParity, _CCDigest, _CCDigestBlockSize, 
-                       _CCDigestCreate, _CCDigestCreateByOID, _CCDigestDestroy, _CCDigestFinal, 
-                       _CCDigestGetBlockSize, _CCDigestGetBlockSizeFromRef, _CCDigestGetOutputSize, 
-                       _CCDigestGetOutputSizeFromRef, _CCDigestInit, _CCDigestOID, 
-                       _CCDigestOIDLen, _CCDigestOutputSize, _CCDigestReset, _CCDigestUpdate, 
-                       _CCECCryptorComputeSharedSecret, _CCECCryptorCreateFromData, 
-                       _CCECCryptorExportKey, _CCECCryptorExportPublicKey, _CCECCryptorGeneratePair, 
-                       _CCECCryptorGetKeyComponents, _CCECCryptorGetPublicKeyFromPrivateKey, 
-                       _CCECCryptorImportKey, _CCECCryptorImportPublicKey, _CCECCryptorRelease, 
-                       _CCECCryptorSignHash, _CCECCryptorTwinDiversifyEntropySize, 
-                       _CCECCryptorTwinDiversifyKey, _CCECCryptorUnwrapKey, _CCECCryptorVerifyHash, 
-                       _CCECCryptorWrapKey, _CCECGetKeySize, _CCECGetKeyType, _CCHmac, 
-                       _CCHmacClone, _CCHmacCreate, _CCHmacDestroy, _CCHmacFinal, 
-                       _CCHmacInit, _CCHmacOneShot, _CCHmacOutputSize, _CCHmacOutputSizeFromRef, 
-                       _CCHmacUpdate, _CCKDFParametersCreateAnsiX963, _CCKDFParametersCreateCtrHmac, 
-                       _CCKDFParametersCreateCtrHmacFixed, _CCKDFParametersCreateHkdf, 
-                       _CCKDFParametersCreatePbkdf2, _CCKDFParametersDestroy, _CCKeyDerivationHMac, 
-                       _CCKeyDerivationPBKDF, _CCRSACryptorCreateFromData, _CCRSACryptorCreatePublicKeyFromPrivateKey, 
-                       _CCRSACryptorCrypt, _CCRSACryptorDecrypt, _CCRSACryptorEncrypt, 
-                       _CCRSACryptorExport, _CCRSACryptorGeneratePair, _CCRSACryptorGetPublicKeyFromPrivateKey, 
-                       _CCRSACryptorImport, _CCRSACryptorRelease, _CCRSACryptorSign, 
-                       _CCRSACryptorVerify, _CCRSAGetCRTComponents, _CCRSAGetCRTComponentsSizes, 
-                       _CCRSAGetKeyComponents, _CCRSAGetKeySize, _CCRSAGetKeyType, 
-                       _CCRandomCopyBytes, _CCRandomGenerateBytes, _CCRandomUniform, 
-                       _CCSymmetricKeyUnwrap, _CCSymmetricKeyWrap, _CCSymmetricUnwrappedSize, 
-                       _CCSymmetricWrappedSize, _CC_MD2, _CC_MD2_Final, _CC_MD2_Init, 
-                       _CC_MD2_Update, _CC_MD4, _CC_MD4_Final, _CC_MD4_Init, _CC_MD4_Update, 
-                       _CC_MD5, _CC_MD5_Final, _CC_MD5_Init, _CC_MD5_Update, _CC_RC4, 
-                       _CC_RC4_set_key, _CC_SHA1, _CC_SHA1_Final, _CC_SHA1_Init, 
-                       _CC_SHA1_Update, _CC_SHA224, _CC_SHA224_Final, _CC_SHA224_Init, 
-                       _CC_SHA224_Update, _CC_SHA256, _CC_SHA256_Final, _CC_SHA256_Init, 
-                       _CC_SHA256_Update, _CC_SHA384, _CC_SHA384_Final, _CC_SHA384_Init, 
-                       _CC_SHA384_Update, _CC_SHA512, _CC_SHA512_Final, _CC_SHA512_Init, 
-                       _CC_SHA512_Update, _CCrfc3394_iv, _CCrfc3394_ivLen, _CNCRC, 
-                       _CNCRCDumpTable, _CNCRCFinal, _CNCRCInit, _CNCRCRelease, _CNCRCUpdate, 
-                       _CNCRCWeakTest, _CNEncode, _CNEncoderBlocksize, _CNEncoderBlocksizeFromRef, 
-                       _CNEncoderCreate, _CNEncoderCreateCustom, _CNEncoderFinal, 
-                       _CNEncoderGetOutputLength, _CNEncoderGetOutputLengthFromEncoding, 
-                       _CNEncoderRelease, _CNEncoderUpdate, _MD5Final, _ccDRBGGetRngState, 
-                       _ccDevRandomGetRngState, _kCCDHRFC2409Group2, _kCCDHRFC3526Group5, 
-                       _kCCRandomDefault, _kCCRandomDevRandom ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos ]
-uuids:
-  - target:          x86_64-macos
-    value:           49B8F644-5705-3F16-BBE0-6FFF9B17C36E
-install-name:    '/usr/lib/system/libcompiler_rt.dylib'
-current-version: 101.2
-parent-umbrella:
-  - targets:         [ x86_64-macos ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos ]
-    symbols:         [ '$ld$hide$os10.10$___chkstk_darwin', '$ld$hide$os10.10$___extendhfsf2', 
-                       '$ld$hide$os10.10$___truncdfhf2', '$ld$hide$os10.10$___truncsfhf2', 
-                       '$ld$hide$os10.10$_atomic_flag_clear', '$ld$hide$os10.10$_atomic_flag_clear_explicit', 
-                       '$ld$hide$os10.10$_atomic_flag_test_and_set', '$ld$hide$os10.10$_atomic_flag_test_and_set_explicit', 
-                       '$ld$hide$os10.10$_atomic_signal_fence', '$ld$hide$os10.10$_atomic_thread_fence', 
-                       '$ld$hide$os10.11$___chkstk_darwin', '$ld$hide$os10.12$___chkstk_darwin', 
-                       '$ld$hide$os10.13$___chkstk_darwin', '$ld$hide$os10.14$___chkstk_darwin', 
-                       '$ld$hide$os10.4$___absvdi2', '$ld$hide$os10.4$___absvsi2', 
-                       '$ld$hide$os10.4$___absvti2', '$ld$hide$os10.4$___addvdi3', 
-                       '$ld$hide$os10.4$___addvsi3', '$ld$hide$os10.4$___addvti3', 
-                       '$ld$hide$os10.4$___ashldi3', '$ld$hide$os10.4$___ashlti3', 
-                       '$ld$hide$os10.4$___ashrdi3', '$ld$hide$os10.4$___ashrti3', 
-                       '$ld$hide$os10.4$___clear_cache', '$ld$hide$os10.4$___clzdi2', 
-                       '$ld$hide$os10.4$___clzsi2', '$ld$hide$os10.4$___clzti2', 
-                       '$ld$hide$os10.4$___cmpdi2', '$ld$hide$os10.4$___cmpti2', 
-                       '$ld$hide$os10.4$___ctzdi2', '$ld$hide$os10.4$___ctzsi2', 
-                       '$ld$hide$os10.4$___ctzti2', '$ld$hide$os10.4$___divdc3', 
-                       '$ld$hide$os10.4$___divdi3', '$ld$hide$os10.4$___divsc3', 
-                       '$ld$hide$os10.4$___divti3', '$ld$hide$os10.4$___divxc3', 
-                       '$ld$hide$os10.4$___enable_execute_stack', '$ld$hide$os10.4$___ffsdi2', 
-                       '$ld$hide$os10.4$___ffsti2', '$ld$hide$os10.4$___fixdfdi', 
-                       '$ld$hide$os10.4$___fixdfti', '$ld$hide$os10.4$___fixsfdi', 
-                       '$ld$hide$os10.4$___fixsfti', '$ld$hide$os10.4$___fixunsdfdi', 
-                       '$ld$hide$os10.4$___fixunsdfsi', '$ld$hide$os10.4$___fixunsdfti', 
-                       '$ld$hide$os10.4$___fixunssfdi', '$ld$hide$os10.4$___fixunssfsi', 
-                       '$ld$hide$os10.4$___fixunssfti', '$ld$hide$os10.4$___fixunsxfdi', 
-                       '$ld$hide$os10.4$___fixunsxfsi', '$ld$hide$os10.4$___fixunsxfti', 
-                       '$ld$hide$os10.4$___fixxfdi', '$ld$hide$os10.4$___fixxfti', 
-                       '$ld$hide$os10.4$___floatdidf', '$ld$hide$os10.4$___floatdisf', 
-                       '$ld$hide$os10.4$___floatdixf', '$ld$hide$os10.4$___floattidf', 
-                       '$ld$hide$os10.4$___floattisf', '$ld$hide$os10.4$___floattixf', 
-                       '$ld$hide$os10.4$___floatundidf', '$ld$hide$os10.4$___floatundisf', 
-                       '$ld$hide$os10.4$___floatundixf', '$ld$hide$os10.4$___floatuntidf', 
-                       '$ld$hide$os10.4$___floatuntisf', '$ld$hide$os10.4$___floatuntixf', 
-                       '$ld$hide$os10.4$___gcc_personality_v0', '$ld$hide$os10.4$___lshrdi3', 
-                       '$ld$hide$os10.4$___lshrti3', '$ld$hide$os10.4$___moddi3', 
-                       '$ld$hide$os10.4$___modti3', '$ld$hide$os10.4$___muldc3', 
-                       '$ld$hide$os10.4$___muldi3', '$ld$hide$os10.4$___mulsc3', 
-                       '$ld$hide$os10.4$___multi3', '$ld$hide$os10.4$___mulvdi3', 
-                       '$ld$hide$os10.4$___mulvsi3', '$ld$hide$os10.4$___mulvti3', 
-                       '$ld$hide$os10.4$___mulxc3', '$ld$hide$os10.4$___negdi2', 
-                       '$ld$hide$os10.4$___negti2', '$ld$hide$os10.4$___negvdi2', 
-                       '$ld$hide$os10.4$___negvsi2', '$ld$hide$os10.4$___negvti2', 
-                       '$ld$hide$os10.4$___paritydi2', '$ld$hide$os10.4$___paritysi2', 
-                       '$ld$hide$os10.4$___parityti2', '$ld$hide$os10.4$___popcountdi2', 
-                       '$ld$hide$os10.4$___popcountsi2', '$ld$hide$os10.4$___popcountti2', 
-                       '$ld$hide$os10.4$___powidf2', '$ld$hide$os10.4$___powisf2', 
-                       '$ld$hide$os10.4$___powixf2', '$ld$hide$os10.4$___subvdi3', 
-                       '$ld$hide$os10.4$___subvsi3', '$ld$hide$os10.4$___subvti3', 
-                       '$ld$hide$os10.4$___ucmpdi2', '$ld$hide$os10.4$___ucmpti2', 
-                       '$ld$hide$os10.4$___udivdi3', '$ld$hide$os10.4$___udivmoddi4', 
-                       '$ld$hide$os10.4$___udivmodti4', '$ld$hide$os10.4$___udivti3', 
-                       '$ld$hide$os10.4$___umoddi3', '$ld$hide$os10.4$___umodti3', 
-                       '$ld$hide$os10.5$___absvdi2', '$ld$hide$os10.5$___absvsi2', 
-                       '$ld$hide$os10.5$___absvti2', '$ld$hide$os10.5$___addvdi3', 
-                       '$ld$hide$os10.5$___addvsi3', '$ld$hide$os10.5$___addvti3', 
-                       '$ld$hide$os10.5$___ashldi3', '$ld$hide$os10.5$___ashlti3', 
-                       '$ld$hide$os10.5$___ashrdi3', '$ld$hide$os10.5$___ashrti3', 
-                       '$ld$hide$os10.5$___clear_cache', '$ld$hide$os10.5$___clzdi2', 
-                       '$ld$hide$os10.5$___clzsi2', '$ld$hide$os10.5$___clzti2', 
-                       '$ld$hide$os10.5$___cmpdi2', '$ld$hide$os10.5$___cmpti2', 
-                       '$ld$hide$os10.5$___ctzdi2', '$ld$hide$os10.5$___ctzsi2', 
-                       '$ld$hide$os10.5$___ctzti2', '$ld$hide$os10.5$___divdc3', 
-                       '$ld$hide$os10.5$___divdi3', '$ld$hide$os10.5$___divsc3', 
-                       '$ld$hide$os10.5$___divti3', '$ld$hide$os10.5$___divxc3', 
-                       '$ld$hide$os10.5$___enable_execute_stack', '$ld$hide$os10.5$___ffsdi2', 
-                       '$ld$hide$os10.5$___ffsti2', '$ld$hide$os10.5$___fixdfdi', 
-                       '$ld$hide$os10.5$___fixdfti', '$ld$hide$os10.5$___fixsfdi', 
-                       '$ld$hide$os10.5$___fixsfti', '$ld$hide$os10.5$___fixunsdfdi', 
-                       '$ld$hide$os10.5$___fixunsdfsi', '$ld$hide$os10.5$___fixunsdfti', 
-                       '$ld$hide$os10.5$___fixunssfdi', '$ld$hide$os10.5$___fixunssfsi', 
-                       '$ld$hide$os10.5$___fixunssfti', '$ld$hide$os10.5$___fixunsxfdi', 
-                       '$ld$hide$os10.5$___fixunsxfsi', '$ld$hide$os10.5$___fixunsxfti', 
-                       '$ld$hide$os10.5$___fixxfdi', '$ld$hide$os10.5$___fixxfti', 
-                       '$ld$hide$os10.5$___floatdidf', '$ld$hide$os10.5$___floatdisf', 
-                       '$ld$hide$os10.5$___floatdixf', '$ld$hide$os10.5$___floattidf', 
-                       '$ld$hide$os10.5$___floattisf', '$ld$hide$os10.5$___floattixf', 
-                       '$ld$hide$os10.5$___floatundidf', '$ld$hide$os10.5$___floatundisf', 
-                       '$ld$hide$os10.5$___floatundixf', '$ld$hide$os10.5$___floatuntidf', 
-                       '$ld$hide$os10.5$___floatuntisf', '$ld$hide$os10.5$___floatuntixf', 
-                       '$ld$hide$os10.5$___gcc_personality_v0', '$ld$hide$os10.5$___lshrdi3', 
-                       '$ld$hide$os10.5$___lshrti3', '$ld$hide$os10.5$___moddi3', 
-                       '$ld$hide$os10.5$___modti3', '$ld$hide$os10.5$___muldc3', 
-                       '$ld$hide$os10.5$___muldi3', '$ld$hide$os10.5$___mulsc3', 
-                       '$ld$hide$os10.5$___multi3', '$ld$hide$os10.5$___mulvdi3', 
-                       '$ld$hide$os10.5$___mulvsi3', '$ld$hide$os10.5$___mulvti3', 
-                       '$ld$hide$os10.5$___mulxc3', '$ld$hide$os10.5$___negdi2', 
-                       '$ld$hide$os10.5$___negti2', '$ld$hide$os10.5$___negvdi2', 
-                       '$ld$hide$os10.5$___negvsi2', '$ld$hide$os10.5$___negvti2', 
-                       '$ld$hide$os10.5$___paritydi2', '$ld$hide$os10.5$___paritysi2', 
-                       '$ld$hide$os10.5$___parityti2', '$ld$hide$os10.5$___popcountdi2', 
-                       '$ld$hide$os10.5$___popcountsi2', '$ld$hide$os10.5$___popcountti2', 
-                       '$ld$hide$os10.5$___powidf2', '$ld$hide$os10.5$___powisf2', 
-                       '$ld$hide$os10.5$___powixf2', '$ld$hide$os10.5$___subvdi3', 
-                       '$ld$hide$os10.5$___subvsi3', '$ld$hide$os10.5$___subvti3', 
-                       '$ld$hide$os10.5$___ucmpdi2', '$ld$hide$os10.5$___ucmpti2', 
-                       '$ld$hide$os10.5$___udivdi3', '$ld$hide$os10.5$___udivmoddi4', 
-                       '$ld$hide$os10.5$___udivmodti4', '$ld$hide$os10.5$___udivti3', 
-                       '$ld$hide$os10.5$___umoddi3', '$ld$hide$os10.5$___umodti3', 
-                       '$ld$hide$os10.6$___atomic_compare_exchange', '$ld$hide$os10.6$___atomic_compare_exchange_1', 
-                       '$ld$hide$os10.6$___atomic_compare_exchange_2', '$ld$hide$os10.6$___atomic_compare_exchange_4', 
-                       '$ld$hide$os10.6$___atomic_compare_exchange_8', '$ld$hide$os10.6$___atomic_exchange', 
-                       '$ld$hide$os10.6$___atomic_exchange_1', '$ld$hide$os10.6$___atomic_exchange_2', 
-                       '$ld$hide$os10.6$___atomic_exchange_4', '$ld$hide$os10.6$___atomic_exchange_8', 
-                       '$ld$hide$os10.6$___atomic_fetch_add_1', '$ld$hide$os10.6$___atomic_fetch_add_2', 
-                       '$ld$hide$os10.6$___atomic_fetch_add_4', '$ld$hide$os10.6$___atomic_fetch_add_8', 
-                       '$ld$hide$os10.6$___atomic_fetch_and_1', '$ld$hide$os10.6$___atomic_fetch_and_2', 
-                       '$ld$hide$os10.6$___atomic_fetch_and_4', '$ld$hide$os10.6$___atomic_fetch_and_8', 
-                       '$ld$hide$os10.6$___atomic_fetch_or_1', '$ld$hide$os10.6$___atomic_fetch_or_2', 
-                       '$ld$hide$os10.6$___atomic_fetch_or_4', '$ld$hide$os10.6$___atomic_fetch_or_8', 
-                       '$ld$hide$os10.6$___atomic_fetch_sub_1', '$ld$hide$os10.6$___atomic_fetch_sub_2', 
-                       '$ld$hide$os10.6$___atomic_fetch_sub_4', '$ld$hide$os10.6$___atomic_fetch_sub_8', 
-                       '$ld$hide$os10.6$___atomic_fetch_xor_1', '$ld$hide$os10.6$___atomic_fetch_xor_2', 
-                       '$ld$hide$os10.6$___atomic_fetch_xor_4', '$ld$hide$os10.6$___atomic_fetch_xor_8', 
-                       '$ld$hide$os10.6$___atomic_load', '$ld$hide$os10.6$___atomic_load_1', 
-                       '$ld$hide$os10.6$___atomic_load_2', '$ld$hide$os10.6$___atomic_load_4', 
-                       '$ld$hide$os10.6$___atomic_load_8', '$ld$hide$os10.6$___atomic_store', 
-                       '$ld$hide$os10.6$___atomic_store_1', '$ld$hide$os10.6$___atomic_store_2', 
-                       '$ld$hide$os10.6$___atomic_store_4', '$ld$hide$os10.6$___atomic_store_8', 
-                       '$ld$hide$os10.6$___chkstk_darwin', '$ld$hide$os10.6$___extendhfsf2', 
-                       '$ld$hide$os10.6$___truncdfhf2', '$ld$hide$os10.6$___truncsfhf2', 
-                       '$ld$hide$os10.6$_atomic_flag_clear', '$ld$hide$os10.6$_atomic_flag_clear_explicit', 
-                       '$ld$hide$os10.6$_atomic_flag_test_and_set', '$ld$hide$os10.6$_atomic_flag_test_and_set_explicit', 
-                       '$ld$hide$os10.6$_atomic_signal_fence', '$ld$hide$os10.6$_atomic_thread_fence', 
-                       '$ld$hide$os10.7$___atomic_compare_exchange', '$ld$hide$os10.7$___atomic_compare_exchange_1', 
-                       '$ld$hide$os10.7$___atomic_compare_exchange_2', '$ld$hide$os10.7$___atomic_compare_exchange_4', 
-                       '$ld$hide$os10.7$___atomic_compare_exchange_8', '$ld$hide$os10.7$___atomic_exchange', 
-                       '$ld$hide$os10.7$___atomic_exchange_1', '$ld$hide$os10.7$___atomic_exchange_2', 
-                       '$ld$hide$os10.7$___atomic_exchange_4', '$ld$hide$os10.7$___atomic_exchange_8', 
-                       '$ld$hide$os10.7$___atomic_fetch_add_1', '$ld$hide$os10.7$___atomic_fetch_add_2', 
-                       '$ld$hide$os10.7$___atomic_fetch_add_4', '$ld$hide$os10.7$___atomic_fetch_add_8', 
-                       '$ld$hide$os10.7$___atomic_fetch_and_1', '$ld$hide$os10.7$___atomic_fetch_and_2', 
-                       '$ld$hide$os10.7$___atomic_fetch_and_4', '$ld$hide$os10.7$___atomic_fetch_and_8', 
-                       '$ld$hide$os10.7$___atomic_fetch_or_1', '$ld$hide$os10.7$___atomic_fetch_or_2', 
-                       '$ld$hide$os10.7$___atomic_fetch_or_4', '$ld$hide$os10.7$___atomic_fetch_or_8', 
-                       '$ld$hide$os10.7$___atomic_fetch_sub_1', '$ld$hide$os10.7$___atomic_fetch_sub_2', 
-                       '$ld$hide$os10.7$___atomic_fetch_sub_4', '$ld$hide$os10.7$___atomic_fetch_sub_8', 
-                       '$ld$hide$os10.7$___atomic_fetch_xor_1', '$ld$hide$os10.7$___atomic_fetch_xor_2', 
-                       '$ld$hide$os10.7$___atomic_fetch_xor_4', '$ld$hide$os10.7$___atomic_fetch_xor_8', 
-                       '$ld$hide$os10.7$___atomic_load', '$ld$hide$os10.7$___atomic_load_1', 
-                       '$ld$hide$os10.7$___atomic_load_2', '$ld$hide$os10.7$___atomic_load_4', 
-                       '$ld$hide$os10.7$___atomic_load_8', '$ld$hide$os10.7$___atomic_store', 
-                       '$ld$hide$os10.7$___atomic_store_1', '$ld$hide$os10.7$___atomic_store_2', 
-                       '$ld$hide$os10.7$___atomic_store_4', '$ld$hide$os10.7$___atomic_store_8', 
-                       '$ld$hide$os10.7$___chkstk_darwin', '$ld$hide$os10.7$___extendhfsf2', 
-                       '$ld$hide$os10.7$___truncdfhf2', '$ld$hide$os10.7$___truncsfhf2', 
-                       '$ld$hide$os10.7$_atomic_flag_clear', '$ld$hide$os10.7$_atomic_flag_clear_explicit', 
-                       '$ld$hide$os10.7$_atomic_flag_test_and_set', '$ld$hide$os10.7$_atomic_flag_test_and_set_explicit', 
-                       '$ld$hide$os10.7$_atomic_signal_fence', '$ld$hide$os10.7$_atomic_thread_fence', 
-                       '$ld$hide$os10.8$___atomic_compare_exchange', '$ld$hide$os10.8$___atomic_compare_exchange_1', 
-                       '$ld$hide$os10.8$___atomic_compare_exchange_2', '$ld$hide$os10.8$___atomic_compare_exchange_4', 
-                       '$ld$hide$os10.8$___atomic_compare_exchange_8', '$ld$hide$os10.8$___atomic_exchange', 
-                       '$ld$hide$os10.8$___atomic_exchange_1', '$ld$hide$os10.8$___atomic_exchange_2', 
-                       '$ld$hide$os10.8$___atomic_exchange_4', '$ld$hide$os10.8$___atomic_exchange_8', 
-                       '$ld$hide$os10.8$___atomic_fetch_add_1', '$ld$hide$os10.8$___atomic_fetch_add_2', 
-                       '$ld$hide$os10.8$___atomic_fetch_add_4', '$ld$hide$os10.8$___atomic_fetch_add_8', 
-                       '$ld$hide$os10.8$___atomic_fetch_and_1', '$ld$hide$os10.8$___atomic_fetch_and_2', 
-                       '$ld$hide$os10.8$___atomic_fetch_and_4', '$ld$hide$os10.8$___atomic_fetch_and_8', 
-                       '$ld$hide$os10.8$___atomic_fetch_or_1', '$ld$hide$os10.8$___atomic_fetch_or_2', 
-                       '$ld$hide$os10.8$___atomic_fetch_or_4', '$ld$hide$os10.8$___atomic_fetch_or_8', 
-                       '$ld$hide$os10.8$___atomic_fetch_sub_1', '$ld$hide$os10.8$___atomic_fetch_sub_2', 
-                       '$ld$hide$os10.8$___atomic_fetch_sub_4', '$ld$hide$os10.8$___atomic_fetch_sub_8', 
-                       '$ld$hide$os10.8$___atomic_fetch_xor_1', '$ld$hide$os10.8$___atomic_fetch_xor_2', 
-                       '$ld$hide$os10.8$___atomic_fetch_xor_4', '$ld$hide$os10.8$___atomic_fetch_xor_8', 
-                       '$ld$hide$os10.8$___atomic_load', '$ld$hide$os10.8$___atomic_load_1', 
-                       '$ld$hide$os10.8$___atomic_load_2', '$ld$hide$os10.8$___atomic_load_4', 
-                       '$ld$hide$os10.8$___atomic_load_8', '$ld$hide$os10.8$___atomic_store', 
-                       '$ld$hide$os10.8$___atomic_store_1', '$ld$hide$os10.8$___atomic_store_2', 
-                       '$ld$hide$os10.8$___atomic_store_4', '$ld$hide$os10.8$___atomic_store_8', 
-                       '$ld$hide$os10.8$___chkstk_darwin', '$ld$hide$os10.8$___extendhfsf2', 
-                       '$ld$hide$os10.8$___truncdfhf2', '$ld$hide$os10.8$___truncsfhf2', 
-                       '$ld$hide$os10.8$_atomic_flag_clear', '$ld$hide$os10.8$_atomic_flag_clear_explicit', 
-                       '$ld$hide$os10.8$_atomic_flag_test_and_set', '$ld$hide$os10.8$_atomic_flag_test_and_set_explicit', 
-                       '$ld$hide$os10.8$_atomic_signal_fence', '$ld$hide$os10.8$_atomic_thread_fence', 
-                       '$ld$hide$os10.9$___chkstk_darwin', '$ld$hide$os10.9$___extendhfsf2', 
-                       '$ld$hide$os10.9$___truncdfhf2', '$ld$hide$os10.9$___truncsfhf2', 
-                       '$ld$hide$os10.9$_atomic_flag_clear', '$ld$hide$os10.9$_atomic_flag_clear_explicit', 
-                       '$ld$hide$os10.9$_atomic_flag_test_and_set', '$ld$hide$os10.9$_atomic_flag_test_and_set_explicit', 
-                       '$ld$hide$os10.9$_atomic_signal_fence', '$ld$hide$os10.9$_atomic_thread_fence', 
-                       ___absvdi2, ___absvsi2, ___absvti2, ___addvdi3, ___addvsi3, 
-                       ___addvti3, ___ashldi3, ___ashlti3, ___ashrdi3, ___ashrti3, 
-                       ___atomic_compare_exchange, ___atomic_compare_exchange_1, 
-                       ___atomic_compare_exchange_2, ___atomic_compare_exchange_4, 
-                       ___atomic_compare_exchange_8, ___atomic_exchange, ___atomic_exchange_1, 
-                       ___atomic_exchange_2, ___atomic_exchange_4, ___atomic_exchange_8, 
-                       ___atomic_fetch_add_1, ___atomic_fetch_add_2, ___atomic_fetch_add_4, 
-                       ___atomic_fetch_add_8, ___atomic_fetch_and_1, ___atomic_fetch_and_2, 
-                       ___atomic_fetch_and_4, ___atomic_fetch_and_8, ___atomic_fetch_or_1, 
-                       ___atomic_fetch_or_2, ___atomic_fetch_or_4, ___atomic_fetch_or_8, 
-                       ___atomic_fetch_sub_1, ___atomic_fetch_sub_2, ___atomic_fetch_sub_4, 
-                       ___atomic_fetch_sub_8, ___atomic_fetch_xor_1, ___atomic_fetch_xor_2, 
-                       ___atomic_fetch_xor_4, ___atomic_fetch_xor_8, ___atomic_load, 
-                       ___atomic_load_1, ___atomic_load_2, ___atomic_load_4, ___atomic_load_8, 
-                       ___atomic_store, ___atomic_store_1, ___atomic_store_2, ___atomic_store_4, 
-                       ___atomic_store_8, ___chkstk_darwin, ___clear_cache, ___clzdi2, 
-                       ___clzsi2, ___clzti2, ___cmpdi2, ___cmpti2, ___ctzdi2, ___ctzsi2, 
-                       ___ctzti2, ___divdc3, ___divdi3, ___divsc3, ___divti3, ___divxc3, 
-                       ___enable_execute_stack, ___extendhfsf2, ___ffsdi2, ___ffsti2, 
-                       ___fixdfdi, ___fixdfti, ___fixsfdi, ___fixsfti, ___fixunsdfdi, 
-                       ___fixunsdfsi, ___fixunsdfti, ___fixunssfdi, ___fixunssfsi, 
-                       ___fixunssfti, ___fixunsxfdi, ___fixunsxfsi, ___fixunsxfti, 
-                       ___fixxfdi, ___fixxfti, ___floatdidf, ___floatdisf, ___floatdixf, 
-                       ___floattidf, ___floattisf, ___floattixf, ___floatundidf, 
-                       ___floatundisf, ___floatundixf, ___floatuntidf, ___floatuntisf, 
-                       ___floatuntixf, ___gcc_personality_v0, ___gnu_f2h_ieee, ___gnu_h2f_ieee, 
-                       ___lshrdi3, ___lshrti3, ___moddi3, ___modti3, ___muldc3, ___muldi3, 
-                       ___mulodi4, ___mulosi4, ___muloti4, ___mulsc3, ___multi3, 
-                       ___mulvdi3, ___mulvsi3, ___mulvti3, ___mulxc3, ___negdi2, 
-                       ___negti2, ___negvdi2, ___negvsi2, ___negvti2, ___paritydi2, 
-                       ___paritysi2, ___parityti2, ___popcountdi2, ___popcountsi2, 
-                       ___popcountti2, ___powidf2, ___powisf2, ___powixf2, ___subvdi3, 
-                       ___subvsi3, ___subvti3, ___truncdfhf2, ___truncsfhf2, ___ucmpdi2, 
-                       ___ucmpti2, ___udivdi3, ___udivmoddi4, ___udivmodti4, ___udivti3, 
-                       ___umoddi3, ___umodti3, _atomic_flag_clear, _atomic_flag_clear_explicit, 
-                       _atomic_flag_test_and_set, _atomic_flag_test_and_set_explicit, 
-                       _atomic_signal_fence, _atomic_thread_fence ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           3C481225-21E7-370A-A30E-0CCFDD64A92C
-  - target:          x86_64-maccatalyst
-    value:           3C481225-21E7-370A-A30E-0CCFDD64A92C
-install-name:    '/usr/lib/system/libcopyfile.dylib'
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _copyfile, _copyfile_state_alloc, _copyfile_state_free, _copyfile_state_get, 
-                       _copyfile_state_set, _fcopyfile, _xattr_flags_from_name, _xattr_intent_with_flags, 
-                       _xattr_name_with_flags, _xattr_name_without_flags, _xattr_preserve_for_intent ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           60567BF8-80FA-359A-B2F3-A3BAEFB288FD
-  - target:          x86_64-maccatalyst
-    value:           60567BF8-80FA-359A-B2F3-A3BAEFB288FD
-install-name:    '/usr/lib/system/libcorecrypto.dylib'
-current-version: 866.140.1
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-allowable-clients:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    clients:         [ cc_fips_test, corecrypto_test ]
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _cc_abort, _cc_atfork_child, _cc_atfork_parent, _cc_atfork_prepare, 
-                       _cc_clear, _cc_cmp_safe, _cc_muxp, _ccaes_cbc_decrypt_mode, 
-                       _ccaes_cbc_encrypt_mode, _ccaes_ccm_decrypt_mode, _ccaes_ccm_encrypt_mode, 
-                       _ccaes_cfb8_decrypt_mode, _ccaes_cfb8_encrypt_mode, _ccaes_cfb_decrypt_mode, 
-                       _ccaes_cfb_encrypt_mode, _ccaes_ctr_crypt_mode, _ccaes_ecb_decrypt_mode, 
-                       _ccaes_ecb_encrypt_mode, _ccaes_gcm_decrypt_mode, _ccaes_gcm_encrypt_mode, 
-                       _ccaes_gladman_cbc_decrypt_mode, _ccaes_gladman_cbc_encrypt_mode, 
-                       _ccaes_intel_cbc_decrypt_aesni_mode, _ccaes_intel_cbc_decrypt_opt_mode, 
-                       _ccaes_intel_cbc_encrypt_aesni_mode, _ccaes_intel_cbc_encrypt_opt_mode, 
-                       _ccaes_intel_ecb_decrypt_aesni_mode, _ccaes_intel_ecb_decrypt_opt_mode, 
-                       _ccaes_intel_ecb_encrypt_aesni_mode, _ccaes_intel_ecb_encrypt_opt_mode, 
-                       _ccaes_intel_xts_decrypt_aesni_mode, _ccaes_intel_xts_decrypt_opt_mode, 
-                       _ccaes_intel_xts_encrypt_aesni_mode, _ccaes_intel_xts_encrypt_opt_mode, 
-                       _ccaes_ltc_ecb_decrypt_mode, _ccaes_ltc_ecb_encrypt_mode, 
-                       _ccaes_ofb_crypt_mode, _ccaes_siv_decrypt_mode, _ccaes_siv_encrypt_mode, 
-                       _ccaes_siv_hmac_sha256_decrypt_mode, _ccaes_siv_hmac_sha256_encrypt_mode, 
-                       _ccaes_xts_decrypt_mode, _ccaes_xts_encrypt_mode, _ccansikdf_x963, 
-                       _ccblowfish_cbc_decrypt_mode, _ccblowfish_cbc_encrypt_mode, 
-                       _ccblowfish_cfb8_decrypt_mode, _ccblowfish_cfb8_encrypt_mode, 
-                       _ccblowfish_cfb_decrypt_mode, _ccblowfish_cfb_encrypt_mode, 
-                       _ccblowfish_ctr_crypt_mode, _ccblowfish_ecb_decrypt_mode, 
-                       _ccblowfish_ecb_encrypt_mode, _ccblowfish_ofb_crypt_mode, 
-                       _cccast_cbc_decrypt_mode, _cccast_cbc_encrypt_mode, _cccast_cfb8_decrypt_mode, 
-                       _cccast_cfb8_encrypt_mode, _cccast_cfb_decrypt_mode, _cccast_cfb_encrypt_mode, 
-                       _cccast_ctr_crypt_mode, _cccast_ecb_decrypt_mode, _cccast_ecb_encrypt_mode, 
-                       _cccast_ofb_crypt_mode, _cccbc_one_shot, _ccchacha20, _ccchacha20_final, 
-                       _ccchacha20_init, _ccchacha20_reset, _ccchacha20_setcounter, 
-                       _ccchacha20_setnonce, _ccchacha20_update, _ccchacha20poly1305_aad, 
-                       _ccchacha20poly1305_decrypt, _ccchacha20poly1305_decrypt_oneshot, 
-                       _ccchacha20poly1305_encrypt, _ccchacha20poly1305_encrypt_oneshot, 
-                       _ccchacha20poly1305_finalize, _ccchacha20poly1305_incnonce, 
-                       _ccchacha20poly1305_info, _ccchacha20poly1305_init, _ccchacha20poly1305_reset, 
-                       _ccchacha20poly1305_setnonce, _ccchacha20poly1305_verify, 
-                       _ccckg_contributor_commit, _ccckg_contributor_finish, _ccckg_init, 
-                       _ccckg_owner_finish, _ccckg_owner_generate_share, _ccckg_sizeof_commitment, 
-                       _ccckg_sizeof_ctx, _ccckg_sizeof_opening, _ccckg_sizeof_share, 
-                       _cccmac_final_generate, _cccmac_final_verify, _cccmac_init, 
-                       _cccmac_one_shot_generate, _cccmac_one_shot_verify, _cccmac_update, 
-                       _cccurve25519, _ccder_decode_bitstring, _ccder_decode_constructed_tl, 
-                       _ccder_decode_constructed_tl_strict, _ccder_decode_dhparam_n, 
-                       _ccder_decode_dhparams, _ccder_decode_eckey, _ccder_decode_len, 
-                       _ccder_decode_len_strict, _ccder_decode_oid, _ccder_decode_rsa_priv, 
-                       _ccder_decode_rsa_priv_n, _ccder_decode_rsa_pub, _ccder_decode_rsa_pub_n, 
-                       _ccder_decode_rsa_pub_x509, _ccder_decode_rsa_pub_x509_n, 
-                       _ccder_decode_seqii, _ccder_decode_seqii_strict, _ccder_decode_sequence_tl, 
-                       _ccder_decode_sequence_tl_strict, _ccder_decode_tag, _ccder_decode_tl, 
-                       _ccder_decode_tl_strict, _ccder_decode_uint, _ccder_decode_uint64, 
-                       _ccder_decode_uint_n, _ccder_decode_uint_strict, _ccder_encode_body, 
-                       _ccder_encode_body_nocopy, _ccder_encode_constructed_tl, _ccder_encode_dhparams, 
-                       _ccder_encode_dhparams_size, _ccder_encode_eckey, _ccder_encode_eckey_size, 
-                       _ccder_encode_implicit_integer, _ccder_encode_implicit_octet_string, 
-                       _ccder_encode_implicit_raw_octet_string, _ccder_encode_implicit_uint64, 
-                       _ccder_encode_integer, _ccder_encode_len, _ccder_encode_octet_string, 
-                       _ccder_encode_oid, _ccder_encode_raw_octet_string, _ccder_encode_rsa_priv, 
-                       _ccder_encode_rsa_priv_size, _ccder_encode_rsa_pub, _ccder_encode_rsa_pub_size, 
-                       _ccder_encode_tag, _ccder_encode_tl, _ccder_encode_uint64, 
-                       _ccder_sizeof, _ccder_sizeof_implicit_integer, _ccder_sizeof_implicit_octet_string, 
-                       _ccder_sizeof_implicit_raw_octet_string, _ccder_sizeof_implicit_uint64, 
-                       _ccder_sizeof_integer, _ccder_sizeof_len, _ccder_sizeof_octet_string, 
-                       _ccder_sizeof_oid, _ccder_sizeof_raw_octet_string, _ccder_sizeof_tag, 
-                       _ccder_sizeof_uint64, _ccdes3_cbc_decrypt_mode, _ccdes3_cbc_encrypt_mode, 
-                       _ccdes3_cfb8_decrypt_mode, _ccdes3_cfb8_encrypt_mode, _ccdes3_cfb_decrypt_mode, 
-                       _ccdes3_cfb_encrypt_mode, _ccdes3_ctr_crypt_mode, _ccdes3_ecb_decrypt_mode, 
-                       _ccdes3_ecb_encrypt_mode, _ccdes3_ltc_ecb_decrypt_mode, _ccdes3_ltc_ecb_encrypt_mode, 
-                       _ccdes3_ofb_crypt_mode, _ccdes_cbc_cksum, _ccdes_cbc_decrypt_mode, 
-                       _ccdes_cbc_encrypt_mode, _ccdes_cfb8_decrypt_mode, _ccdes_cfb8_encrypt_mode, 
-                       _ccdes_cfb_decrypt_mode, _ccdes_cfb_encrypt_mode, _ccdes_ctr_crypt_mode, 
-                       _ccdes_ecb_decrypt_mode, _ccdes_ecb_encrypt_mode, _ccdes_key_is_weak, 
-                       _ccdes_key_set_odd_parity, _ccdes_ofb_crypt_mode, _ccdh_compute_key, 
-                       _ccdh_compute_shared_secret, _ccdh_export_pub, _ccdh_generate_key, 
-                       _ccdh_gp_apple768, _ccdh_gp_rfc2409group02, _ccdh_gp_rfc3526group05, 
-                       _ccdh_gp_rfc3526group14, _ccdh_gp_rfc3526group15, _ccdh_gp_rfc3526group16, 
-                       _ccdh_gp_rfc3526group17, _ccdh_gp_rfc3526group18, _ccdh_gp_rfc5114_MODP_1024_160, 
-                       _ccdh_gp_rfc5114_MODP_2048_224, _ccdh_gp_rfc5114_MODP_2048_256, 
-                       _ccdh_import_full, _ccdh_import_priv, _ccdh_import_pub, _ccdh_init_gp, 
-                       _ccdh_init_gp_from_bytes, _ccdh_init_gp_with_order, _ccdh_lookup_gp, 
-                       _ccdigest, _ccdigest_init, _ccdigest_oid_lookup, _ccdigest_update, 
-                       _ccdrbg_factory_nistctr, _ccdrbg_factory_nisthmac, _ccec_compact_export, 
-                       _ccec_compact_export_pub, _ccec_compact_generate_key, _ccec_compact_import_priv, 
-                       _ccec_compact_import_priv_size, _ccec_compact_import_pub, 
-                       _ccec_compact_import_pub_size, _ccec_compact_transform_key, 
-                       _ccec_compute_key, _ccec_cp_192, _ccec_cp_224, _ccec_cp_256, 
-                       _ccec_cp_384, _ccec_cp_521, _ccec_curve_for_length_lookup, 
-                       _ccec_der_export_diversified_pub, _ccec_der_export_diversified_pub_size, 
-                       _ccec_der_export_priv, _ccec_der_export_priv_size, _ccec_der_import_diversified_pub, 
-                       _ccec_der_import_priv, _ccec_der_import_priv_keytype, _ccec_diversify_min_entropy_len, 
-                       _ccec_diversify_priv_twin, _ccec_diversify_pub, _ccec_diversify_pub_twin, 
-                       _ccec_export_pub, _ccec_generate_key, _ccec_generate_key_deterministic, 
-                       _ccec_generate_key_fips, _ccec_generate_key_internal_fips, 
-                       _ccec_generate_key_legacy, _ccec_get_cp, _ccec_get_fullkey_components, 
-                       _ccec_get_pubkey_components, _ccec_import_pub, _ccec_keysize_is_supported, 
-                       _ccec_make_priv, _ccec_make_pub, _ccec_pairwise_consistency_check, 
-                       _ccec_print_full_key, _ccec_print_public_key, _ccec_raw_import_priv_only, 
-                       _ccec_raw_import_pub, _ccec_rfc6637_dh_curve_p256, _ccec_rfc6637_dh_curve_p521, 
-                       _ccec_rfc6637_unwrap_key, _ccec_rfc6637_unwrap_sha256_kek_aes128, 
-                       _ccec_rfc6637_unwrap_sha512_kek_aes256, _ccec_rfc6637_wrap_key, 
-                       _ccec_rfc6637_wrap_key_diversified, _ccec_rfc6637_wrap_key_size, 
-                       _ccec_rfc6637_wrap_sha256_kek_aes128, _ccec_rfc6637_wrap_sha512_kek_aes256, 
-                       _ccec_sign, _ccec_sign_composite, _ccec_signature_r_s_size, 
-                       _ccec_validate_pub, _ccec_verify, _ccec_verify_composite, 
-                       _ccec_x963_export, _ccec_x963_import_priv, _ccec_x963_import_priv_size, 
-                       _ccec_x963_import_pub, _ccec_x963_import_pub_size, _ccecdh_compute_shared_secret, 
-                       _ccecdh_generate_key, _ccecies_decrypt_gcm, _ccecies_decrypt_gcm_composite, 
-                       _ccecies_decrypt_gcm_from_shared_secret, _ccecies_decrypt_gcm_plaintext_size, 
-                       _ccecies_decrypt_gcm_plaintext_size_cp, _ccecies_decrypt_gcm_setup, 
-                       _ccecies_encrypt_gcm, _ccecies_encrypt_gcm_ciphertext_size, 
-                       _ccecies_encrypt_gcm_composite, _ccecies_encrypt_gcm_from_shared_secret, 
-                       _ccecies_encrypt_gcm_setup, _ccecies_import_eph_pub, _ccecies_pub_key_size, 
-                       _ccecies_pub_key_size_cp, _cced25519_make_key_pair, _cced25519_make_pub, 
-                       _cced25519_sign, _cced25519_verify, _ccgcm_inc_iv, _ccgcm_init_with_iv, 
-                       _ccgcm_one_shot, _ccgcm_one_shot_legacy, _ccgcm_set_iv_legacy, 
-                       _cchkdf, _cchkdf_expand, _cchkdf_extract, _cchmac, _cchmac_final, 
-                       _cchmac_init, _cchmac_update, _ccmd2_ltc_di, _ccmd4_ltc_di, 
-                       _ccmd5_di, _ccmd5_ltc_di, _ccmgf, _ccmode_factory_cbc_decrypt, 
-                       _ccmode_factory_cbc_encrypt, _ccmode_factory_ccm_decrypt, 
-                       _ccmode_factory_ccm_encrypt, _ccmode_factory_cfb8_decrypt, 
-                       _ccmode_factory_cfb8_encrypt, _ccmode_factory_cfb_decrypt, 
-                       _ccmode_factory_cfb_encrypt, _ccmode_factory_ctr_crypt, _ccmode_factory_gcm_decrypt, 
-                       _ccmode_factory_gcm_encrypt, _ccmode_factory_ofb_crypt, _ccmode_factory_omac_decrypt, 
-                       _ccmode_factory_omac_encrypt, _ccmode_factory_siv_decrypt, 
-                       _ccmode_factory_siv_encrypt, _ccmode_factory_xts_decrypt, 
-                       _ccmode_factory_xts_encrypt, _ccn_add, _ccn_add1, _ccn_addmul1, 
-                       _ccn_bitlen, _ccn_cmp, _ccn_div_equal_size_ws, _ccn_div_euclid, 
-                       _ccn_div_euclid_ws, _ccn_lprint, _ccn_mul, _ccn_mul1, _ccn_n, 
-                       _ccn_print, _ccn_random_bits, _ccn_read_uint, _ccn_set, _ccn_shift_right, 
-                       _ccn_sub, _ccn_sub1, _ccn_write_int, _ccn_write_int_size, 
-                       _ccn_write_uint, _ccn_write_uint_padded_ct, _ccn_write_uint_size, 
-                       _ccn_zero_multi, _ccnistkdf_ctr_cmac, _ccnistkdf_ctr_cmac_fixed, 
-                       _ccnistkdf_ctr_hmac, _ccnistkdf_ctr_hmac_fixed, _ccnistkdf_fb_hmac, 
-                       _ccnistkdf_fb_hmac_fixed, _ccpad_cts1_decrypt, _ccpad_cts1_encrypt, 
-                       _ccpad_cts2_decrypt, _ccpad_cts2_encrypt, _ccpad_cts3_decrypt, 
-                       _ccpad_cts3_encrypt, _ccpad_pkcs7_decode, _ccpad_pkcs7_decrypt, 
-                       _ccpad_pkcs7_ecb_decrypt, _ccpad_pkcs7_ecb_encrypt, _ccpad_pkcs7_encrypt, 
-                       _ccpad_xts_decrypt, _ccpad_xts_encrypt, _ccpbkdf2_hmac, _ccpoly1305, 
-                       _ccpoly1305_final, _ccpoly1305_init, _ccpoly1305_update, _ccrc2_cbc_decrypt_mode, 
-                       _ccrc2_cbc_encrypt_mode, _ccrc2_cfb8_decrypt_mode, _ccrc2_cfb8_encrypt_mode, 
-                       _ccrc2_cfb_decrypt_mode, _ccrc2_cfb_encrypt_mode, _ccrc2_ctr_crypt_mode, 
-                       _ccrc2_ecb_decrypt_mode, _ccrc2_ecb_encrypt_mode, _ccrc2_ofb_crypt_mode, 
-                       _ccrc4, _ccrc4_eay, _ccrmd160_ltc_di, _ccrng, _ccrng_drbg_done, 
-                       _ccrng_drbg_init, _ccrng_drbg_init_withdrbg, _ccrng_drbg_reseed, 
-                       _ccrng_ecfips_test_init, _ccrng_pbkdf2_prng_init, _ccrng_rsafips_test_init, 
-                       _ccrng_rsafips_test_set_next, _ccrng_sequence_init, _ccrng_system_done, 
-                       _ccrng_system_init, _ccrng_test_done, _ccrng_test_init, _ccrng_uniform, 
-                       _ccrsa_decrypt_eme_pkcs1v15, _ccrsa_decrypt_eme_pkcs1v15_blinded, 
-                       _ccrsa_decrypt_oaep, _ccrsa_decrypt_oaep_blinded, _ccrsa_dump_full_key, 
-                       _ccrsa_dump_public_key, _ccrsa_eme_pkcs1v15_decode, _ccrsa_eme_pkcs1v15_encode, 
-                       _ccrsa_emsa_pkcs1v15_encode, _ccrsa_emsa_pkcs1v15_verify, 
-                       _ccrsa_emsa_pss_decode, _ccrsa_emsa_pss_encode, _ccrsa_encrypt_eme_pkcs1v15, 
-                       _ccrsa_encrypt_oaep, _ccrsa_export_pub, _ccrsa_generate_fips186_key, 
-                       _ccrsa_generate_fips186_key_trace, _ccrsa_generate_key, _ccrsa_get_fullkey_components, 
-                       _ccrsa_get_pubkey_components, _ccrsa_import_pub, _ccrsa_init_pub, 
-                       _ccrsa_make_fips186_key, _ccrsa_make_fips186_key_trace, _ccrsa_make_priv, 
-                       _ccrsa_make_pub, _ccrsa_oaep_decode_parameter, _ccrsa_oaep_encode_parameter, 
-                       _ccrsa_priv_crypt, _ccrsa_priv_crypt_blinded, _ccrsa_pub_crypt, 
-                       _ccrsa_pubkeylength, _ccrsa_sign_pkcs1v15, _ccrsa_sign_pkcs1v15_blinded, 
-                       _ccrsa_sign_pss, _ccrsa_sign_pss_blinded, _ccrsa_verify_pkcs1v15, 
-                       _ccrsa_verify_pkcs1v15_allowshortsigs, _ccrsa_verify_pss, 
-                       _ccscrypt, _ccscrypt_storage_size, _ccsha1_di, _ccsha1_eay_di, 
-                       _ccsha1_ltc_di, _ccsha1_vng_intel_SupplementalSSE3_di, _ccsha224_di, 
-                       _ccsha224_ltc_di, _ccsha224_vng_intel_SupplementalSSE3_di, 
-                       _ccsha256_di, _ccsha256_ltc_di, _ccsha256_vng_intel_SupplementalSSE3_di, 
-                       _ccsha384_di, _ccsha384_ltc_di, _ccsha512_di, _ccsha512_ltc_di, 
-                       _ccsiv_hmac_aad, _ccsiv_hmac_ciphertext_size, _ccsiv_hmac_crypt, 
-                       _ccsiv_hmac_init, _ccsiv_hmac_one_shot, _ccsiv_hmac_plaintext_size, 
-                       _ccsiv_hmac_reset, _ccsiv_hmac_set_nonce, _ccspake_cp_256, 
-                       _ccspake_cp_384, _ccspake_cp_521, _ccspake_generate_L, _ccspake_kex_generate, 
-                       _ccspake_kex_process, _ccspake_mac_compute, _ccspake_mac_hkdf_cmac_aes128_sha256, 
-                       _ccspake_mac_hkdf_hmac_sha256, _ccspake_mac_hkdf_hmac_sha512, 
-                       _ccspake_mac_verify_and_get_session_key, _ccspake_prover_init, 
-                       _ccspake_sizeof_ctx, _ccspake_sizeof_point, _ccspake_sizeof_w, 
-                       _ccspake_verifier_init, _ccsrp_client_process_challenge, _ccsrp_client_start_authentication, 
-                       _ccsrp_client_verify_session, _ccsrp_generate_salt_and_verification, 
-                       _ccsrp_generate_verifier, _ccsrp_gp_rfc5054_1024, _ccsrp_gp_rfc5054_2048, 
-                       _ccsrp_gp_rfc5054_3072, _ccsrp_gp_rfc5054_4096, _ccsrp_gp_rfc5054_8192, 
-                       _ccsrp_server_compute_session, _ccsrp_server_generate_public_key, 
-                       _ccsrp_server_start_authentication, _ccsrp_server_verify_session, 
-                       _ccsrp_test_calculations, _ccss_shamir_parameters_init, _ccss_shamir_parameters_maximum_secret_length, 
-                       _ccss_shamir_share_bag_add_share, _ccss_shamir_share_bag_init, 
-                       _ccss_shamir_share_bag_recover_secret, _ccss_shamir_share_export, 
-                       _ccss_shamir_share_generator_generate_share, _ccss_shamir_share_generator_init, 
-                       _ccss_shamir_share_import, _ccss_shamir_share_init, _ccss_shamir_share_sizeof_y, 
-                       _ccvrf_derive_public_key, _ccvrf_factory_irtfdraft03, _ccvrf_factory_irtfdraft03_default, 
-                       _ccvrf_proof_to_hash, _ccvrf_prove, _ccvrf_sizeof_hash, _ccvrf_sizeof_proof, 
-                       _ccvrf_sizeof_public_key, _ccvrf_sizeof_secret_key, _ccvrf_verify, 
-                       _ccwrap_auth_decrypt, _ccwrap_auth_decrypt_withiv, _ccwrap_auth_encrypt, 
-                       _ccwrap_auth_encrypt_withiv, _ccwrap_unwrapped_size, _ccwrap_wrapped_size, 
-                       _ccxts_one_shot, _ccz_add, _ccz_addi, _ccz_bit, _ccz_bitlen, 
-                       _ccz_cmp, _ccz_cmpi, _ccz_divmod, _ccz_expmod, _ccz_free, 
-                       _ccz_gcd, _ccz_init, _ccz_invmod, _ccz_is_negative, _ccz_is_one, 
-                       _ccz_is_prime, _ccz_is_zero, _ccz_lcm, _ccz_lprint, _ccz_lsl, 
-                       _ccz_lsr, _ccz_mod, _ccz_mul, _ccz_muli, _ccz_mulmod, _ccz_neg, 
-                       _ccz_print, _ccz_random_bits, _ccz_read_radix, _ccz_read_uint, 
-                       _ccz_set, _ccz_set_bit, _ccz_seti, _ccz_size, _ccz_sqr, _ccz_sqrmod, 
-                       _ccz_sub, _ccz_subi, _ccz_trailing_zeros, _ccz_write_int, 
-                       _ccz_write_int_size, _ccz_write_radix, _ccz_write_radix_size, 
-                       _ccz_write_uint, _ccz_write_uint_size, _ccz_zero, _cczp_init, 
-                       _cczp_init_with_recip, _cczp_inv, _cczp_power, _cczp_power_fast, 
-                       _csss_shamir_share_bag_can_recover_secret, _fipspost_post, 
-                       _fipspost_trace_vtable ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           CD9C059C-91D9-30E8-8926-5B9CD0D5D4F5
-  - target:          x86_64-maccatalyst
-    value:           CD9C059C-91D9-30E8-8926-5B9CD0D5D4F5
-install-name:    '/usr/lib/system/libdispatch.dylib'
-current-version: 1173.100.2
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ '$ld$hide$os10.12$_dispatch_assert_queue', '$ld$hide$os10.12$_dispatch_assert_queue_not', 
-                       '$ld$hide$os10.12$_dispatch_queue_create_with_target', __dispatch_begin_NSAutoReleasePool, 
-                       __dispatch_bug, __dispatch_data_destructor_free, __dispatch_data_destructor_munmap, 
-                       __dispatch_data_destructor_none, __dispatch_data_destructor_vm_deallocate, 
-                       __dispatch_data_empty, __dispatch_data_format_type_base32, 
-                       __dispatch_data_format_type_base32hex, __dispatch_data_format_type_base64, 
-                       __dispatch_data_format_type_none, __dispatch_data_format_type_utf16be, 
-                       __dispatch_data_format_type_utf16le, __dispatch_data_format_type_utf8, 
-                       __dispatch_data_format_type_utf_any, __dispatch_end_NSAutoReleasePool, 
-                       __dispatch_get_main_queue_handle_4CF, __dispatch_get_main_queue_port_4CF, 
-                       __dispatch_iocntl, __dispatch_is_fork_of_multithreaded_parent, 
-                       __dispatch_is_multithreaded, __dispatch_log, __dispatch_mach_hooks_install_default, 
-                       __dispatch_main_q, __dispatch_main_queue_callback_4CF, __dispatch_poll_for_events_4launchd, 
-                       __dispatch_prohibit_transition_to_multithreaded, __dispatch_pthread_root_queue_create_with_observer_hooks_4IOHID, 
-                       __dispatch_queue_attr_concurrent, __dispatch_queue_is_exclusively_owned_by_current_thread_4IOHID, 
-                       __dispatch_runloop_root_queue_create_4CF, __dispatch_runloop_root_queue_get_port_4CF, 
-                       __dispatch_runloop_root_queue_perform_4CF, __dispatch_runloop_root_queue_wakeup_4CF, 
-                       __dispatch_source_set_runloop_timer_4CF, __dispatch_source_type_data_add, 
-                       __dispatch_source_type_data_or, __dispatch_source_type_data_replace, 
-                       __dispatch_source_type_interval, __dispatch_source_type_mach_recv, 
-                       __dispatch_source_type_mach_send, __dispatch_source_type_memorypressure, 
-                       __dispatch_source_type_memorystatus, __dispatch_source_type_nw_channel, 
-                       __dispatch_source_type_proc, __dispatch_source_type_read, 
-                       __dispatch_source_type_signal, __dispatch_source_type_sock, 
-                       __dispatch_source_type_timer, __dispatch_source_type_vfs, 
-                       __dispatch_source_type_vm, __dispatch_source_type_vnode, __dispatch_source_type_write, 
-                       __dispatch_source_will_reenable_kevent_4NW, __dispatch_wait_for_enqueuer, 
-                       __dispatch_workloop_set_observer_hooks_4IOHID, __dispatch_workloop_should_yield_4NW, 
-                       __firehose_spi_version, __os_object_alloc, __os_object_alloc_realized, 
-                       __os_object_dealloc, __os_object_release, __os_object_release_internal, 
-                       __os_object_release_internal_n, __os_object_release_without_xref_dispose, 
-                       __os_object_retain, __os_object_retain_internal, __os_object_retain_internal_n, 
-                       __os_object_retain_with_resurrect, _dispatch_activate, _dispatch_after, 
-                       _dispatch_after_f, _dispatch_allocator_layout, _dispatch_apply, 
-                       _dispatch_apply_f, _dispatch_assert_queue, '_dispatch_assert_queue$V2', 
-                       _dispatch_assert_queue_barrier, _dispatch_assert_queue_not, 
-                       '_dispatch_assert_queue_not$V2', _dispatch_async, _dispatch_async_and_wait, 
-                       _dispatch_async_and_wait_f, _dispatch_async_enforce_qos_class_f, 
-                       _dispatch_async_f, _dispatch_atfork_child, _dispatch_atfork_parent, 
-                       _dispatch_atfork_prepare, _dispatch_barrier_async, _dispatch_barrier_async_and_wait, 
-                       _dispatch_barrier_async_and_wait_f, _dispatch_barrier_async_f, 
-                       _dispatch_barrier_sync, _dispatch_barrier_sync_f, _dispatch_benchmark, 
-                       _dispatch_benchmark_f, _dispatch_block_cancel, _dispatch_block_create, 
-                       _dispatch_block_create_with_qos_class, _dispatch_block_create_with_voucher, 
-                       _dispatch_block_create_with_voucher_and_qos_class, _dispatch_block_notify, 
-                       _dispatch_block_perform, _dispatch_block_testcancel, _dispatch_block_wait, 
-                       _dispatch_channel_async, _dispatch_channel_async_f, _dispatch_channel_cancel, 
-                       _dispatch_channel_create, _dispatch_channel_drain, _dispatch_channel_drain_f, 
-                       _dispatch_channel_enqueue, _dispatch_channel_foreach_work_item_peek, 
-                       _dispatch_channel_foreach_work_item_peek_f, _dispatch_channel_testcancel, 
-                       _dispatch_channel_wakeup, _dispatch_data_apply, _dispatch_data_apply_f, 
-                       _dispatch_data_copy_region, _dispatch_data_create, _dispatch_data_create_alloc, 
-                       _dispatch_data_create_concat, _dispatch_data_create_f, _dispatch_data_create_map, 
-                       _dispatch_data_create_subrange, _dispatch_data_create_with_transform, 
-                       _dispatch_data_get_flattened_bytes_4libxpc, _dispatch_data_get_size, 
-                       _dispatch_data_make_memory_entry, _dispatch_debug, _dispatch_debugv, 
-                       _dispatch_get_context, _dispatch_get_current_queue, _dispatch_get_global_queue, 
-                       _dispatch_get_specific, _dispatch_group_async, _dispatch_group_async_f, 
-                       _dispatch_group_create, _dispatch_group_enter, _dispatch_group_leave, 
-                       _dispatch_group_notify, _dispatch_group_notify_f, _dispatch_group_wait, 
-                       _dispatch_io_barrier, _dispatch_io_barrier_f, _dispatch_io_close, 
-                       _dispatch_io_create, _dispatch_io_create_f, _dispatch_io_create_with_io, 
-                       _dispatch_io_create_with_io_f, _dispatch_io_create_with_path, 
-                       _dispatch_io_create_with_path_f, _dispatch_io_get_descriptor, 
-                       _dispatch_io_read, _dispatch_io_read_f, _dispatch_io_set_high_water, 
-                       _dispatch_io_set_interval, _dispatch_io_set_low_water, _dispatch_io_write, 
-                       _dispatch_io_write_f, _dispatch_mach_cancel, _dispatch_mach_connect, 
-                       _dispatch_mach_create, _dispatch_mach_create_4libxpc, _dispatch_mach_create_f, 
-                       _dispatch_mach_get_checkin_port, _dispatch_mach_handoff_reply, 
-                       _dispatch_mach_handoff_reply_f, _dispatch_mach_hooks_install_4libxpc, 
-                       _dispatch_mach_mig_demux, _dispatch_mach_mig_demux_get_context, 
-                       _dispatch_mach_msg_create, _dispatch_mach_msg_get_context, 
-                       _dispatch_mach_msg_get_msg, _dispatch_mach_receive_barrier, 
-                       _dispatch_mach_receive_barrier_f, _dispatch_mach_reconnect, 
-                       _dispatch_mach_request_no_senders, _dispatch_mach_send, _dispatch_mach_send_and_wait_for_reply, 
-                       _dispatch_mach_send_barrier, _dispatch_mach_send_barrier_f, 
-                       _dispatch_mach_send_with_result, _dispatch_mach_send_with_result_and_async_reply_4libxpc, 
-                       _dispatch_mach_send_with_result_and_wait_for_reply, _dispatch_mach_set_flags, 
-                       _dispatch_main, _dispatch_mig_server, _dispatch_once, _dispatch_once_f, 
-                       _dispatch_pthread_root_queue_copy_current, _dispatch_pthread_root_queue_create, 
-                       _dispatch_queue_attr_make_initially_inactive, _dispatch_queue_attr_make_with_autorelease_frequency, 
-                       _dispatch_queue_attr_make_with_overcommit, _dispatch_queue_attr_make_with_qos_class, 
-                       _dispatch_queue_create, _dispatch_queue_create_with_accounting_override_voucher, 
-                       _dispatch_queue_create_with_target, '_dispatch_queue_create_with_target$V2', 
-                       _dispatch_queue_get_label, _dispatch_queue_get_qos_class, 
-                       _dispatch_queue_get_specific, _dispatch_queue_offsets, _dispatch_queue_set_label_nocopy, 
-                       _dispatch_queue_set_specific, _dispatch_queue_set_width, _dispatch_read, 
-                       _dispatch_read_f, _dispatch_release, _dispatch_resume, _dispatch_retain, 
-                       _dispatch_semaphore_create, _dispatch_semaphore_signal, _dispatch_semaphore_wait, 
-                       _dispatch_set_context, _dispatch_set_finalizer_f, _dispatch_set_qos_class, 
-                       _dispatch_set_qos_class_fallback, _dispatch_set_qos_class_floor, 
-                       _dispatch_set_target_queue, _dispatch_source_cancel, _dispatch_source_cancel_and_wait, 
-                       _dispatch_source_create, _dispatch_source_get_data, _dispatch_source_get_extended_data, 
-                       _dispatch_source_get_handle, _dispatch_source_get_mask, _dispatch_source_merge_data, 
-                       _dispatch_source_set_cancel_handler, _dispatch_source_set_cancel_handler_f, 
-                       _dispatch_source_set_event_handler, _dispatch_source_set_event_handler_f, 
-                       _dispatch_source_set_mandatory_cancel_handler, _dispatch_source_set_mandatory_cancel_handler_f, 
-                       _dispatch_source_set_registration_handler, _dispatch_source_set_registration_handler_f, 
-                       _dispatch_source_set_timer, _dispatch_source_testcancel, _dispatch_suspend, 
-                       _dispatch_sync, _dispatch_sync_f, _dispatch_time, _dispatch_tsd_indexes, 
-                       _dispatch_walltime, _dispatch_workloop_copy_current, _dispatch_workloop_create, 
-                       _dispatch_workloop_create_inactive, _dispatch_workloop_is_current, 
-                       _dispatch_workloop_set_autorelease_frequency, _dispatch_workloop_set_cpupercent, 
-                       _dispatch_workloop_set_qos_class, _dispatch_workloop_set_qos_class_floor, 
-                       _dispatch_workloop_set_scheduler_priority, _dispatch_write, 
-                       _dispatch_write_f, _libdispatch_init, _mach_voucher_persona_for_originator, 
-                       _mach_voucher_persona_self, _os_release, _os_retain, _voucher_activity_create_with_data, 
-                       _voucher_activity_create_with_location, _voucher_activity_flush, 
-                       _voucher_activity_get_logging_preferences, _voucher_activity_get_metadata_buffer, 
-                       _voucher_activity_id_allocate, _voucher_activity_initialize_4libtrace, 
-                       _voucher_activity_should_send_strings, _voucher_activity_trace, 
-                       _voucher_activity_trace_v, _voucher_activity_trace_v_2, _voucher_adopt, 
-                       _voucher_copy, _voucher_copy_with_persona_mach_voucher, _voucher_copy_without_importance, 
-                       _voucher_create_with_mach_msg, _voucher_decrement_importance_count4CF, 
-                       _voucher_get_activity_id, _voucher_get_activity_id_and_creator, 
-                       _voucher_get_current_persona, _voucher_get_current_persona_originator_info, 
-                       _voucher_get_current_persona_proximate_info, _voucher_kvoucher_debug, 
-                       _voucher_replace_default_voucher ]
-    objc-classes:    [ OS_dispatch_channel, OS_dispatch_data, OS_dispatch_disk, OS_dispatch_group, 
-                       OS_dispatch_io, OS_dispatch_mach, OS_dispatch_mach_msg, OS_dispatch_object, 
-                       OS_dispatch_operation, OS_dispatch_queue, OS_dispatch_queue_attr, 
-                       OS_dispatch_queue_concurrent, OS_dispatch_queue_global, OS_dispatch_queue_main, 
-                       OS_dispatch_queue_serial, OS_dispatch_semaphore, OS_dispatch_source, 
-                       OS_dispatch_workloop, OS_object, OS_voucher ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           789A18C2-8AC7-3C88-813D-CD674376585D
-  - target:          x86_64-maccatalyst
-    value:           789A18C2-8AC7-3C88-813D-CD674376585D
-install-name:    '/usr/lib/system/libdyld.dylib'
-current-version: 750.6
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _NSAddImage, _NSAddLibrary, _NSAddLibraryWithSearching, _NSAddressOfSymbol, 
-                       _NSCreateObjectFileImageFromFile, _NSCreateObjectFileImageFromMemory, 
-                       _NSDestroyObjectFileImage, _NSGetSectionDataInObjectFileImage, 
-                       _NSInstallLinkEditErrorHandlers, _NSIsSymbolDefinedInObjectFileImage, 
-                       _NSIsSymbolNameDefined, _NSIsSymbolNameDefinedInImage, _NSIsSymbolNameDefinedWithHint, 
-                       _NSLibraryNameForModule, _NSLinkEditError, _NSLinkModule, 
-                       _NSLookupAndBindSymbol, _NSLookupAndBindSymbolWithHint, _NSLookupSymbolInImage, 
-                       _NSLookupSymbolInModule, _NSModuleForSymbol, _NSNameOfModule, 
-                       _NSNameOfSymbol, _NSSymbolDefinitionCountInObjectFileImage, 
-                       _NSSymbolDefinitionNameInObjectFileImage, _NSSymbolReferenceCountInObjectFileImage, 
-                       _NSSymbolReferenceNameInObjectFileImage, _NSUnLinkModule, 
-                       _NSVersionOfLinkTimeLibrary, _NSVersionOfRunTimeLibrary, _NXArgc, 
-                       _NXArgv, __NSGetExecutablePath, __ZN5dyld316compatFuncLookupEPKcPPv, 
-                       __ZN5dyld318entryVectorForDyldE, ___progname, __dyld_all_twolevel_modules_prebound, 
-                       __dyld_atfork_parent, __dyld_atfork_prepare, __dyld_bind_fully_image_containing_address, 
-                       __dyld_find_unwind_sections, __dyld_for_each_objc_class, __dyld_for_each_objc_protocol, 
-                       __dyld_fork_child, __dyld_get_image_header, __dyld_get_image_header_containing_address, 
-                       __dyld_get_image_name, __dyld_get_image_slide, __dyld_get_image_uuid, 
-                       __dyld_get_image_vmaddr_slide, __dyld_get_objc_selector, __dyld_get_shared_cache_range, 
-                       __dyld_get_shared_cache_uuid, __dyld_image_containing_address, 
-                       __dyld_image_count, __dyld_images_for_addresses, __dyld_initializer, 
-                       __dyld_is_memory_immutable, __dyld_launched_prebound, __dyld_lookup_and_bind, 
-                       __dyld_lookup_and_bind_fully, __dyld_lookup_and_bind_with_hint, 
-                       __dyld_missing_symbol_abort, __dyld_objc_notify_register, 
-                       __dyld_present, __dyld_process_info_create, __dyld_process_info_for_each_image, 
-                       __dyld_process_info_for_each_segment, __dyld_process_info_get_cache, 
-                       __dyld_process_info_get_platform, __dyld_process_info_get_state, 
-                       __dyld_process_info_notify, __dyld_process_info_notify_main, 
-                       __dyld_process_info_notify_release, __dyld_process_info_notify_retain, 
-                       __dyld_process_info_release, __dyld_process_info_retain, __dyld_register_driverkit_main, 
-                       __dyld_register_for_bulk_image_loads, __dyld_register_for_image_loads, 
-                       __dyld_register_func_for_add_image, __dyld_register_func_for_remove_image, 
-                       __dyld_shared_cache_is_locally_built, __dyld_shared_cache_optimized, 
-                       __tlv_atexit, __tlv_bootstrap, __tlv_exit, _dladdr, _dlclose, 
-                       _dlerror, _dlopen, _dlopen_preflight, _dlsym, _dyldVersionNumber, 
-                       _dyldVersionString, _dyld_dynamic_interpose, _dyld_get_active_platform, 
-                       _dyld_get_base_platform, _dyld_get_image_versions, _dyld_get_min_os_version, 
-                       _dyld_get_program_min_os_version, _dyld_get_program_sdk_version, 
-                       _dyld_get_sdk_version, _dyld_has_inserted_or_interposing_libraries, 
-                       _dyld_image_header_containing_address, _dyld_image_path_containing_address, 
-                       _dyld_is_simulator_platform, _dyld_minos_at_least, _dyld_need_closure, 
-                       _dyld_process_is_restricted, _dyld_program_minos_at_least, 
-                       _dyld_program_sdk_at_least, _dyld_sdk_at_least, _dyld_shared_cache_file_path, 
-                       _dyld_shared_cache_find_iterate_text, _dyld_shared_cache_iterate_text, 
-                       _dyld_shared_cache_some_image_overridden, _environ, dyld_stub_binder ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           DB3337BE-01CA-3425-BD0C-87774FC0CDC0
-  - target:          x86_64-maccatalyst
-    value:           DB3337BE-01CA-3425-BD0C-87774FC0CDC0
-install-name:    '/usr/lib/system/libkeymgr.dylib'
-current-version: 30
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ ___keymgr_dwarf2_register_sections, ___keymgr_initializer, 
-                       __keymgr_get_and_lock_processwide_ptr, __keymgr_get_and_lock_processwide_ptr_2, 
-                       __keymgr_get_lock_count_processwide_ptr, __keymgr_get_lockmode_processwide_ptr, 
-                       __keymgr_set_and_unlock_processwide_ptr, __keymgr_set_lockmode_processwide_ptr, 
-                       __keymgr_unlock_processwide_ptr, _keymgrVersionNumber, _keymgrVersionString ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           AFBCBDD3-0B55-3ECD-8E04-A73A3A57356B
-  - target:          x86_64-maccatalyst
-    value:           AFBCBDD3-0B55-3ECD-8E04-A73A3A57356B
-install-name:    '/usr/lib/system/liblaunch.dylib'
-current-version: 1738.140.1
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ __spawn_via_launchd, __vproc_get_last_exit_status, __vproc_grab_subset, 
-                       __vproc_kickstart_by_label, __vproc_log, __vproc_log_error, 
-                       __vproc_logv, __vproc_pid_is_managed, __vproc_post_fork_ping, 
-                       __vproc_send_signal_by_label, __vproc_set_global_on_demand, 
-                       __vproc_standby_begin, __vproc_standby_count, __vproc_standby_end, 
-                       __vproc_standby_timeout, __vproc_transaction_begin, __vproc_transaction_count, 
-                       __vproc_transaction_count_for_pid, __vproc_transaction_end, 
-                       __vproc_transaction_set_clean_callback, __vproc_transaction_try_exit, 
-                       __vproc_transactions_enable, __vprocmgr_detach_from_console, 
-                       __vprocmgr_getsocket, __vprocmgr_init, __vprocmgr_log_drain, 
-                       __vprocmgr_log_forward, __vprocmgr_move_subset_to_user, __vprocmgr_switch_to_session, 
-                       _bootstrap_check_in, _bootstrap_check_in2, _bootstrap_check_in3, 
-                       _bootstrap_create_server, _bootstrap_create_service, _bootstrap_get_root, 
-                       _bootstrap_info, _bootstrap_init, _bootstrap_look_up, _bootstrap_look_up2, 
-                       _bootstrap_look_up3, _bootstrap_look_up_per_user, _bootstrap_lookup_children, 
-                       _bootstrap_parent, _bootstrap_register, _bootstrap_register2, 
-                       _bootstrap_status, _bootstrap_strerror, _bootstrap_subset, 
-                       _bootstrap_unprivileged, _create_and_switch_to_per_session_launchd, 
-                       _launch_data_alloc, _launch_data_array_get_count, _launch_data_array_get_index, 
-                       _launch_data_array_set_index, _launch_data_copy, _launch_data_dict_get_count, 
-                       _launch_data_dict_insert, _launch_data_dict_iterate, _launch_data_dict_lookup, 
-                       _launch_data_dict_remove, _launch_data_free, _launch_data_get_bool, 
-                       _launch_data_get_errno, _launch_data_get_fd, _launch_data_get_integer, 
-                       _launch_data_get_machport, _launch_data_get_opaque, _launch_data_get_opaque_size, 
-                       _launch_data_get_real, _launch_data_get_string, _launch_data_get_type, 
-                       _launch_data_new_bool, _launch_data_new_errno, _launch_data_new_fd, 
-                       _launch_data_new_integer, _launch_data_new_machport, _launch_data_new_opaque, 
-                       _launch_data_new_real, _launch_data_new_string, _launch_data_pack, 
-                       _launch_data_set_bool, _launch_data_set_errno, _launch_data_set_fd, 
-                       _launch_data_set_integer, _launch_data_set_machport, _launch_data_set_opaque, 
-                       _launch_data_set_real, _launch_data_set_string, _launch_data_unpack, 
-                       _launch_get_fd, _launch_msg, _launch_socket_service_check_in, 
-                       _launch_wait, _launchd_close, _launchd_fdopen, _launchd_getfd, 
-                       _launchd_msg_recv, _launchd_msg_send, _load_launchd_jobs_at_loginwindow_prompt, 
-                       _mpm_uncork_fork, _mpm_wait, _reboot2, _vproc_release, _vproc_retain, 
-                       _vproc_standby_begin, _vproc_standby_end, _vproc_swap_complex, 
-                       _vproc_swap_integer, _vproc_swap_string, _vproc_transaction_begin, 
-                       _vproc_transaction_end, _vprocmgr_lookup_vproc ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           AA613A9C-961A-3B67-B696-4622FA59FC4E
-  - target:          x86_64-maccatalyst
-    value:           AA613A9C-961A-3B67-B696-4622FA59FC4E
-install-name:    '/usr/lib/system/libmacho.dylib'
-current-version: 959.0.1
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _NXCombineCpuSubtypes, _NXFindBestFatArch, _NXFindBestFatArch_64, 
-                       _NXFreeArchInfo, _NXGetAllArchInfos, _NXGetArchInfoFromCpuType, 
-                       _NXGetArchInfoFromName, _NXGetLocalArchInfo, _get_edata, _get_end, 
-                       _get_etext, _getsectbyname, _getsectbynamefromheader, _getsectbynamefromheader_64, 
-                       _getsectbynamefromheaderwithswap, _getsectbynamefromheaderwithswap_64, 
-                       _getsectdata, _getsectdatafromFramework, _getsectdatafromheader, 
-                       _getsectdatafromheader_64, _getsectiondata, _getsegbyname, 
-                       _getsegmentdata, _slot_name, _swap_build_tool_version, _swap_build_version_command, 
-                       _swap_dyld_info_command, _swap_dylib_command, _swap_dylib_module, 
-                       _swap_dylib_module_64, _swap_dylib_reference, _swap_dylib_table_of_contents, 
-                       _swap_dylinker_command, _swap_dysymtab_command, _swap_encryption_command, 
-                       _swap_encryption_command_64, _swap_entry_point_command, _swap_fat_arch, 
-                       _swap_fat_arch_64, _swap_fat_header, _swap_fvmfile_command, 
-                       _swap_fvmlib_command, _swap_hppa_fp_thread_state, _swap_hppa_frame_thread_state, 
-                       _swap_hppa_integer_thread_state, _swap_i386_exception_state, 
-                       _swap_i386_float_state, _swap_i386_thread_state, _swap_i860_thread_state_regs, 
-                       _swap_ident_command, _swap_indirect_symbols, _swap_linkedit_data_command, 
-                       _swap_linker_option_command, _swap_load_command, _swap_m68k_thread_state_68882, 
-                       _swap_m68k_thread_state_regs, _swap_m68k_thread_state_user_reg, 
-                       _swap_m88110_thread_state_impl_t, _swap_m88k_thread_state_grf_t, 
-                       _swap_m88k_thread_state_user_t, _swap_m88k_thread_state_xrf_t, 
-                       _swap_mach_header, _swap_mach_header_64, _swap_nlist, _swap_nlist_64, 
-                       _swap_note_command, _swap_ppc_exception_state_t, _swap_ppc_float_state_t, 
-                       _swap_ppc_thread_state_t, _swap_prebind_cksum_command, _swap_prebound_dylib_command, 
-                       _swap_ranlib, _swap_ranlib_64, _swap_relocation_info, _swap_routines_command, 
-                       _swap_routines_command_64, _swap_rpath_command, _swap_section, 
-                       _swap_section_64, _swap_segment_command, _swap_segment_command_64, 
-                       _swap_source_version_command, _swap_sparc_thread_state_fpu, 
-                       _swap_sparc_thread_state_regs, _swap_sub_client_command, _swap_sub_framework_command, 
-                       _swap_sub_library_command, _swap_sub_umbrella_command, _swap_symseg_command, 
-                       _swap_symtab_command, _swap_thread_command, _swap_twolevel_hint, 
-                       _swap_twolevel_hints_command, _swap_uuid_command, _swap_version_min_command, 
-                       _swap_x86_debug_state, _swap_x86_debug_state32, _swap_x86_debug_state64, 
-                       _swap_x86_exception_state, _swap_x86_exception_state64, _swap_x86_float_state, 
-                       _swap_x86_float_state64, _swap_x86_state_hdr, _swap_x86_thread_state, 
-                       _swap_x86_thread_state64 ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           F234E51D-FD0B-3EE4-B679-AE3EE9C536C3
-  - target:          x86_64-maccatalyst
-    value:           F234E51D-FD0B-3EE4-B679-AE3EE9C536C3
-install-name:    '/usr/lib/system/libquarantine.dylib'
-current-version: 110.40.3
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ ___esp_check, ___esp_check_ns, ___esp_enabled, ___esp_notify, 
-                       ___esp_notify_ns, ___libquarantineVersionNumber, ___libquarantineVersionString, 
-                       ___qtn_syscall_quarantine_getinfo_fd, ___qtn_syscall_quarantine_getinfo_mount_point, 
-                       ___qtn_syscall_quarantine_getinfo_path, ___qtn_syscall_quarantine_getprocinfo, 
-                       ___qtn_syscall_quarantine_setinfo_fd, ___qtn_syscall_quarantine_setinfo_mount_point, 
-                       ___qtn_syscall_quarantine_setinfo_path, ___qtn_syscall_quarantine_setprocinfo, 
-                       ___qtn_syscall_responsibility_get, ___qtn_syscall_responsibility_get2, 
-                       ___qtn_syscall_responsibility_get3, ___qtn_syscall_responsibility_set, 
-                       ___qtn_syscall_responsibility_set_audittoken_for_caller, ___qtn_syscall_responsibility_set_audittoken_for_self, 
-                       ___qtn_syscall_responsibility_set_caller_for_caller, ___qtn_syscall_responsibility_set_hosted_path, 
-                       __qtn_error, __qtn_file_alloc, __qtn_file_apply_to_fd, __qtn_file_apply_to_mount_point, 
-                       __qtn_file_apply_to_path, __qtn_file_clone, __qtn_file_free, 
-                       __qtn_file_get_flags, __qtn_file_get_identifier, __qtn_file_get_metadata, 
-                       __qtn_file_get_metadata_size, __qtn_file_get_timestamp, __qtn_file_init, 
-                       __qtn_file_init_with_data, __qtn_file_init_with_fd, __qtn_file_init_with_mount_point, 
-                       __qtn_file_init_with_path, __qtn_file_set_flags, __qtn_file_set_identifier, 
-                       __qtn_file_set_metadata, __qtn_file_set_timestamp, __qtn_file_to_data, 
-                       __qtn_label_name, __qtn_proc_alloc, __qtn_proc_apply_to_self, 
-                       __qtn_proc_clone, __qtn_proc_free, __qtn_proc_get_flags, __qtn_proc_get_identifier, 
-                       __qtn_proc_get_metadata, __qtn_proc_get_metadata_size, __qtn_proc_get_path_exclusion_pattern, 
-                       __qtn_proc_init, __qtn_proc_init_with_data, __qtn_proc_init_with_self, 
-                       __qtn_proc_set_flags, __qtn_proc_set_identifier, __qtn_proc_set_metadata, 
-                       __qtn_proc_set_path_exclusion_pattern, __qtn_proc_to_data, 
-                       __qtn_xattr_name, _qtn_proc_init_with_pid, _responsibility_get_attribution_for_audittoken, 
-                       _responsibility_get_pid_responsible_for_pid, _responsibility_get_responsible_audit_token_for_audit_token, 
-                       _responsibility_get_responsible_for_pid, _responsibility_get_uniqueid_responsible_for_pid, 
-                       _responsibility_identity_get_binary_entitlement_data, _responsibility_identity_get_binary_is_platform, 
-                       _responsibility_identity_get_binary_offset, _responsibility_identity_get_binary_path, 
-                       _responsibility_identity_get_binary_signing_id, _responsibility_identity_get_binary_team_id, 
-                       _responsibility_identity_get_hosted_path, _responsibility_identity_get_persistent_identifier, 
-                       _responsibility_identity_get_user_uuid, _responsibility_identity_release, 
-                       _responsibility_init, _responsibility_set_audittoken_responsible_for_caller, 
-                       _responsibility_set_audittoken_responsible_for_self, _responsibility_set_caller_responsible_for_self, 
-                       _responsibility_set_hosted_path, _responsibility_set_pid_responsible_for_pid, 
-                       _responsibility_spawnattrs_getdisclaim, _responsibility_spawnattrs_setdisclaim ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           7C7EFC79-BD24-33EF-B073-06AED234593E
-  - target:          x86_64-maccatalyst
-    value:           7C7EFC79-BD24-33EF-B073-06AED234593E
-install-name:    '/usr/lib/system/libremovefile.dylib'
-current-version: 48
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ ___removefile_init_random, ___removefile_random_char, ___removefile_randomize_buffer, 
-                       ___removefile_rename_unlink, ___removefile_sunlink, ___removefile_tree_walker, 
-                       _removefile, _removefile_cancel, _removefile_state_alloc, 
-                       _removefile_state_free, _removefile_state_get, _removefile_state_set ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           1563EE02-0657-3B78-99BE-A947C24122EF
-  - target:          x86_64-maccatalyst
-    value:           1563EE02-0657-3B78-99BE-A947C24122EF
-install-name:    '/usr/lib/system/libsystem_asl.dylib'
-current-version: 377.60.2
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _ASL_LEVEL_TO_STRING, __asl_evaluate_send, __asl_fork_child, 
-                       __asl_lib_log, __asl_log_args_to_xpc, __asl_msg_dump, __asl_mt_shim_fork_child, 
-                       __asl_mt_shim_send_message, __asl_server_cancel_direct_watch, 
-                       __asl_server_control_query, __asl_server_create_aux_link, 
-                       __asl_server_match, __asl_server_message, __asl_server_query_2, 
-                       __asl_server_register_direct_watch, _asl_add_log_file, _asl_add_output, 
-                       _asl_add_output_file, _asl_append, _asl_base_msg, _asl_client_add_output_file, 
-                       _asl_client_get_control, _asl_client_kvdict, _asl_client_match, 
-                       _asl_client_open, _asl_client_open_from_file, _asl_client_release, 
-                       _asl_client_remove_output_file, _asl_client_retain, _asl_client_search, 
-                       _asl_client_send, _asl_client_set_control, _asl_client_set_filter, 
-                       _asl_client_set_output_file_filter, _asl_close, _asl_close_auxiliary_file, 
-                       _asl_core_check_access, _asl_core_decode_buffer, _asl_core_encode_buffer, 
-                       _asl_core_error, _asl_core_get_service_port, _asl_core_htonq, 
-                       _asl_core_level_to_string, _asl_core_new_msg_id, _asl_core_ntohq, 
-                       _asl_core_parse_time, _asl_core_str_match, _asl_core_str_match_c_time, 
-                       _asl_core_str_match_char, _asl_core_str_to_size, _asl_core_str_to_time, 
-                       _asl_core_str_to_uint32, _asl_core_string_hash, _asl_core_time_to_str, 
-                       _asl_count, _asl_create_auxiliary_file, _asl_fetch_key_val_op, 
-                       _asl_file_close, _asl_file_compact, _asl_file_ctime, _asl_file_fetch, 
-                       _asl_file_fetch_next, _asl_file_fetch_previous, _asl_file_filter, 
-                       _asl_file_filter_level, _asl_file_list_add, _asl_file_list_close, 
-                       _asl_file_list_match, _asl_file_list_match_end, _asl_file_list_match_next, 
-                       _asl_file_list_match_start, _asl_file_match, _asl_file_open_read, 
-                       _asl_file_open_write, _asl_file_read_set_position, _asl_file_release, 
-                       _asl_file_retain, _asl_file_save, _asl_file_size, _asl_filesystem_path, 
-                       _asl_format, _asl_format_message, _asl_free, _asl_get, _asl_get_filter, 
-                       _asl_get_index, _asl_get_local_control, _asl_get_type, _asl_get_value_for_key, 
-                       _asl_key, _asl_legacy1_close, _asl_legacy1_fetch, _asl_legacy1_match, 
-                       _asl_legacy1_open, _asl_list_from_string, _asl_log, _asl_log_auxiliary_location, 
-                       _asl_log_descriptor, _asl_log_message, _asl_match, _asl_msg_cmp, 
-                       _asl_msg_cmp_list, _asl_msg_copy, _asl_msg_count, _asl_msg_fetch, 
-                       _asl_msg_from_string, _asl_msg_get_val_for_key, _asl_msg_key, 
-                       _asl_msg_list_append, _asl_msg_list_count, _asl_msg_list_from_string, 
-                       _asl_msg_list_get_index, _asl_msg_list_insert, _asl_msg_list_match, 
-                       _asl_msg_list_new, _asl_msg_list_new_count, _asl_msg_list_next, 
-                       _asl_msg_list_prepend, _asl_msg_list_prev, _asl_msg_list_release, 
-                       _asl_msg_list_remove_index, _asl_msg_list_reset_iteration, 
-                       _asl_msg_list_retain, _asl_msg_list_search, _asl_msg_list_to_asl_string, 
-                       _asl_msg_list_to_string, _asl_msg_lookup, _asl_msg_merge, 
-                       _asl_msg_new, _asl_msg_release, _asl_msg_retain, _asl_msg_set_key_val, 
-                       _asl_msg_set_key_val_op, _asl_msg_to_string, _asl_msg_type, 
-                       _asl_msg_unset, _asl_msg_unset_index, _asl_new, _asl_next, 
-                       _asl_object_append, _asl_object_count, _asl_object_get_key_val_op_at_index, 
-                       _asl_object_get_object_at_index, _asl_object_get_val_op_for_key, 
-                       _asl_object_match, _asl_object_next, _asl_object_prepend, 
-                       _asl_object_prev, _asl_object_remove_object_at_index, _asl_object_search, 
-                       _asl_object_set_iteration_index, _asl_object_set_key_val_op, 
-                       _asl_object_unset_key, _asl_open, _asl_open_from_file, _asl_open_path, 
-                       _asl_parse_time, _asl_prepend, _asl_prev, _asl_release, _asl_remote_notify_name, 
-                       _asl_remove_log_file, _asl_remove_output, _asl_remove_output_file, 
-                       _asl_reset_iteration, _asl_retain, _asl_search, _asl_send, 
-                       _asl_set, _asl_set_filter, _asl_set_key_val_op, _asl_set_local_control, 
-                       _asl_set_output_file_filter, _asl_set_query, _asl_store_close, 
-                       _asl_store_location, _asl_store_match, _asl_store_match_next, 
-                       _asl_store_match_start, _asl_store_match_timeout, _asl_store_max_file_size, 
-                       _asl_store_open_aux, _asl_store_open_read, _asl_store_open_write, 
-                       _asl_store_release, _asl_store_retain, _asl_store_save, _asl_store_set_flags, 
-                       _asl_store_statistics, _asl_store_sweep_file_cache, _asl_string_allocated_size, 
-                       _asl_string_append, _asl_string_append_asl_key, _asl_string_append_asl_msg, 
-                       _asl_string_append_char_no_encoding, _asl_string_append_no_encoding, 
-                       _asl_string_append_no_encoding_len, _asl_string_append_op, 
-                       _asl_string_append_xml_tag, _asl_string_bytes, _asl_string_length, 
-                       _asl_string_new, _asl_string_release, _asl_string_release_return_bytes, 
-                       _asl_string_retain, _asl_syslog_faciliy_name_to_num, _asl_syslog_faciliy_num_to_name, 
-                       _asl_trigger_aslmanager, _asl_unset, _asl_unset_key, _asl_vlog, 
-                       _aslresponse_free, _aslresponse_next, _closelog, _openlog, 
-                       _setlogmask, _syslog, '_syslog$DARWIN_EXTSN', _vsyslog ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           0D53847E-AF5F-3ACF-B51F-A15DEA4DEC58
-  - target:          x86_64-maccatalyst
-    value:           0D53847E-AF5F-3ACF-B51F-A15DEA4DEC58
-install-name:    '/usr/lib/system/libsystem_blocks.dylib'
-current-version: 74
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _Block_size, __Block_copy, __Block_extended_layout, __Block_has_signature, 
-                       __Block_isDeallocating, __Block_layout, __Block_object_assign, 
-                       __Block_object_dispose, __Block_release, __Block_signature, 
-                       __Block_tryRetain, __Block_use_RR2, __Block_use_stret, __NSConcreteAutoBlock, 
-                       __NSConcreteFinalizingBlock, __NSConcreteGlobalBlock, __NSConcreteMallocBlock, 
-                       __NSConcreteStackBlock, __NSConcreteWeakBlockVariable ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           BBDED5E6-A646-3EED-B33A-91E4331EA063
-  - target:          x86_64-maccatalyst
-    value:           BBDED5E6-A646-3EED-B33A-91E4331EA063
-install-name:    '/usr/lib/system/libsystem_c.dylib'
-current-version: 1353.100.2
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ '$ld$weak$os10.11$_basename_r', '$ld$weak$os10.11$_clock_getres', 
-                       '$ld$weak$os10.11$_clock_gettime', '$ld$weak$os10.11$_clock_settime', 
-                       '$ld$weak$os10.11$_dirname_r', '$ld$weak$os10.11$_getentropy', 
-                       '$ld$weak$os10.11$_mkostemp', '$ld$weak$os10.11$_mkostemps', 
-                       '$ld$weak$os10.11$_timingsafe_bcmp', '$ld$weak$os10.12$_utimensat', 
-                       __CurrentRuneLocale, __DefaultRuneLocale, __Exit, __NSGetArgc, 
-                       __NSGetArgv, __NSGetEnviron, __NSGetMachExecuteHeader, __NSGetProgname, 
-                       __PathLocale, __Read_RuneMagi, ___Balloc_D2A, ___Bfree_D2A, 
-                       ___ULtod_D2A, ____mb_cur_max, ____mb_cur_max_l, ____runetype, 
-                       ____runetype_l, ____tolower, ____tolower_l, ____toupper, ____toupper_l, 
-                       ___add_ovflpage, ___addel, ___any_on_D2A, ___assert_rtn, ___b2d_D2A, 
-                       ___big_delete, ___big_insert, ___big_keydata, ___big_return, 
-                       ___big_split, ___bigtens_D2A, ___bt_close, ___bt_cmp, ___bt_defcmp, 
-                       ___bt_defpfx, ___bt_delete, ___bt_dleaf, ___bt_fd, ___bt_free, 
-                       ___bt_get, ___bt_new, ___bt_open, ___bt_pgin, ___bt_pgout, 
-                       ___bt_put, ___bt_ret, ___bt_search, ___bt_seq, ___bt_setcur, 
-                       ___bt_split, ___bt_sync, ___buf_free, ___call_hash, ___cleanup, 
-                       ___cmp_D2A, ___collate_equiv_match, ___collate_load_error, 
-                       ___collate_lookup, ___copybits_D2A, ___cxa_atexit, ___cxa_finalize, 
-                       ___cxa_finalize_ranges, ___cxa_thread_atexit, ___d2b_D2A, 
-                       ___dbpanic, ___decrement_D2A, ___default_hash, ___default_utx, 
-                       ___delpair, ___diff_D2A, ___dtoa, ___expand_table, ___fflush, 
-                       ___fgetwc, ___find_bigpair, ___find_last_page, ___fix_locale_grouping_str, 
-                       ___fread, ___free_ovflpage, ___freedtoa, ___gdtoa, ___gdtoa_locks, 
-                       ___get_buf, ___get_page, ___gethex_D2A, ___getonlyClocaleconv, 
-                       ___hash_open, ___hdtoa, ___hexdig_D2A, ___hexdig_init_D2A, 
-                       ___hexnan_D2A, ___hi0bits_D2A, ___hldtoa, ___i2b_D2A, ___ibitmap, 
-                       ___increment_D2A, ___isctype, ___istype, ___istype_l, ___ldtoa, 
-                       ___libc_init, ___lo0bits_D2A, ___log2, ___lshift_D2A, ___maskrune, 
-                       ___maskrune_l, ___match_D2A, ___mb_cur_max, ___mb_sb_limit, 
-                       ___memccpy_chk, ___memcpy_chk, ___memmove_chk, ___memset_chk, 
-                       ___mult_D2A, ___multadd_D2A, ___nrv_alloc_D2A, ___opendir2, 
-                       '___opendir2$INODE64', ___ovfl_delete, ___ovfl_get, ___ovfl_put, 
-                       ___pow5mult_D2A, ___put_page, ___quorem_D2A, ___ratio_D2A, 
-                       ___rec_close, ___rec_delete, ___rec_dleaf, ___rec_fd, ___rec_fmap, 
-                       ___rec_fpipe, ___rec_get, ___rec_iput, ___rec_open, ___rec_put, 
-                       ___rec_ret, ___rec_search, ___rec_seq, ___rec_sync, ___rec_vmap, 
-                       ___rec_vpipe, ___reclaim_buf, ___rshift_D2A, ___rv_alloc_D2A, 
-                       ___s2b_D2A, ___sF, ___sclose, ___sdidinit, ___set_ones_D2A, 
-                       ___setonlyClocaleconv, ___sflags, ___sflush, ___sfp, ___sfvwrite, 
-                       ___sglue, ___sinit, ___slbexpand, ___smakebuf, ___snprintf_chk, 
-                       ___snprintf_object_size_chk, ___split_page, ___sprintf_chk, 
-                       ___sprintf_object_size_chk, ___sread, ___srefill, ___srget, 
-                       ___sseek, ___stack_chk_fail, ___stack_chk_guard, ___stderrp, 
-                       ___stdinp, ___stdoutp, ___stpcpy_chk, ___stpncpy_chk, ___strcat_chk, 
-                       ___strcp_D2A, ___strcpy_chk, ___strlcat_chk, ___strlcpy_chk, 
-                       ___strncat_chk, ___strncpy_chk, ___strtodg, ___strtopdd, ___strtopx, 
-                       ___sum_D2A, ___svfscanf, ___swbuf, ___swhatbuf, ___swrite, 
-                       ___swsetup, ___tens_D2A, ___tinytens_D2A, ___tolower, ___tolower_l, 
-                       ___toupper, ___toupper_l, ___trailz_D2A, ___ulp_D2A, ___ungetc, 
-                       ___ungetwc, ___vsnprintf_chk, ___vsprintf_chk, ___wcwidth, 
-                       ___wcwidth_l, __allocenvstate, __atexit_receipt, __c_locale, 
-                       __cleanup, __closeutx, __copyenv, __cthread_init_routine, 
-                       __deallocenvstate, __endutxent, __flockfile_debug_stub, __fseeko, 
-                       __ftello, __fwalk, __getenvp, __getutxent, __getutxid, __getutxline, 
-                       __inet_aton_check, __init_clock_port, __int_to_time, __libc_fork_child, 
-                       __libc_initializer, __long_to_time, __mkpath_np, __mktemp, 
-                       __openutx, __os_assert_log, __os_assert_log_ctx, __os_assumes_log, 
-                       __os_assumes_log_ctx, __os_avoid_tail_call, __os_crash, __os_crash_callback, 
-                       __os_crash_fmt, __os_debug_log, __os_debug_log_error_str, 
-                       __putenvp, __pututxline, __rand48_add, __rand48_mult, __rand48_seed, 
-                       __readdir_unlocked, '__readdir_unlocked$INODE64', __reclaim_telldir, 
-                       __seekdir, '__seekdir$INODE64', __setenvp, __setutxent, __sigaction_nobind, 
-                       __sigintr, __signal_nobind, __sigvec_nobind, __sread, __sseek, 
-                       __swrite, __time32_to_time, __time64_to_time, __time_to_int, 
-                       __time_to_long, __time_to_time32, __time_to_time64, __unsetenvp, 
-                       __utmpxname, _a64l, _abort, _abort_report_np, _abs, _acl_add_flag_np, 
-                       _acl_add_perm, _acl_calc_mask, _acl_clear_flags_np, _acl_clear_perms, 
-                       _acl_copy_entry, _acl_copy_ext, _acl_copy_ext_native, _acl_copy_int, 
-                       _acl_copy_int_native, _acl_create_entry, _acl_create_entry_np, 
-                       _acl_delete_def_file, _acl_delete_entry, _acl_delete_fd_np, 
-                       _acl_delete_file_np, _acl_delete_flag_np, _acl_delete_link_np, 
-                       _acl_delete_perm, _acl_dup, _acl_free, _acl_from_text, _acl_get_entry, 
-                       _acl_get_fd, _acl_get_fd_np, _acl_get_file, _acl_get_flag_np, 
-                       _acl_get_flagset_np, _acl_get_link_np, _acl_get_perm_np, _acl_get_permset, 
-                       _acl_get_permset_mask_np, _acl_get_qualifier, _acl_get_tag_type, 
-                       _acl_init, _acl_maximal_permset_mask_np, _acl_set_fd, _acl_set_fd_np, 
-                       _acl_set_file, _acl_set_flagset_np, _acl_set_link_np, _acl_set_permset, 
-                       _acl_set_permset_mask_np, _acl_set_qualifier, _acl_set_tag_type, 
-                       _acl_size, _acl_to_text, _acl_valid, _acl_valid_fd_np, _acl_valid_file_np, 
-                       _acl_valid_link, _addr2ascii, _alarm, _alphasort, '_alphasort$INODE64', 
-                       _arc4random, _arc4random_addrandom, _arc4random_buf, _arc4random_stir, 
-                       _arc4random_uniform, _ascii2addr, _asctime, _asctime_r, _asprintf, 
-                       _asprintf_l, _asxprintf, _asxprintf_exec, _atexit, _atexit_b, 
-                       _atof, _atof_l, _atoi, _atoi_l, _atol, _atol_l, _atoll, _atoll_l, 
-                       _backtrace, _backtrace_from_fp, _backtrace_image_offsets, 
-                       _backtrace_symbols, _backtrace_symbols_fd, _basename, _basename_r, 
-                       _bcmp, _bcopy, _brk, _bsd_signal, _bsearch, _bsearch_b, _btowc, 
-                       _btowc_l, _bzero, _catclose, _catgets, _catopen, _cfgetispeed, 
-                       _cfgetospeed, _cfmakeraw, _cfsetispeed, _cfsetospeed, _cfsetspeed, 
-                       _cgetcap, _cgetclose, _cgetent, _cgetfirst, _cgetmatch, _cgetnext, 
-                       _cgetnum, _cgetset, _cgetstr, _cgetustr, _chmodx_np, _clearerr, 
-                       _clearerr_unlocked, _clock, _clock_getres, _clock_gettime, 
-                       _clock_gettime_nsec_np, _clock_port, _clock_sem, _clock_settime, 
-                       _closedir, _compat_mode, _confstr, _copy_printf_domain, _creat, 
-                       '_creat$NOCANCEL', _crypt, _ctermid, _ctermid_r, _ctime, _ctime_r, 
-                       _daemon, '_daemon$1050', _daylight, _dbm_clearerr, _dbm_close, 
-                       _dbm_delete, _dbm_dirfno, _dbm_error, _dbm_fetch, _dbm_firstkey, 
-                       _dbm_nextkey, _dbm_open, _dbm_store, _dbopen, _devname, _devname_r, 
-                       _difftime, _digittoint, _digittoint_l, _dirfd, _dirname, _dirname_r, 
-                       _div, _dprintf, _dprintf_l, _drand48, _duplocale, _dxprintf, 
-                       _dxprintf_exec, _ecvt, _encrypt, _endttyent, _endusershell, 
-                       _endutxent, _endutxent_wtmp, _erand48, _err, _err_set_exit, 
-                       _err_set_exit_b, _err_set_file, _errc, _errx, _execl, _execle, 
-                       _execlp, _execv, _execvP, _execvp, _exit, _f_prealloc, _fchmodx_np, 
-                       _fclose, _fcvt, _fdopen, '_fdopen$DARWIN_EXTSN', _fdopendir, 
-                       '_fdopendir$INODE64', _feof, _feof_unlocked, _ferror, _ferror_unlocked, 
-                       _fflagstostr, _fflush, _fgetc, _fgetln, _fgetpos, _fgetrune, 
-                       _fgets, _fgetwc, _fgetwc_l, _fgetwln, _fgetwln_l, _fgetws, 
-                       _fgetws_l, _fileno, _fileno_unlocked, _filesec_dup, _filesec_free, 
-                       _filesec_get_property, _filesec_init, _filesec_query_property, 
-                       _filesec_set_property, _filesec_unset_property, _flockfile, 
-                       _fmemopen, _fmtcheck, _fmtmsg, _fnmatch, _fopen, '_fopen$DARWIN_EXTSN', 
-                       _fork, _forkpty, _fparseln, _fprintf, _fprintf_l, _fpurge, 
-                       _fputc, _fputrune, _fputs, _fputwc, _fputwc_l, _fputws, _fputws_l, 
-                       _fread, _free_printf_comp, _free_printf_domain, _freelocale, 
-                       _freopen, _fscanf, _fscanf_l, _fseek, _fseeko, _fsetpos, _fstatvfs, 
-                       _fstatx64_np, _fstatx_np, '_fstatx_np$INODE64', _fsync_volume_np, 
-                       _ftell, _ftello, _ftime, _ftok, _ftrylockfile, _fts_children, 
-                       '_fts_children$INODE64', _fts_close, '_fts_close$INODE64', 
-                       _fts_open, '_fts_open$INODE64', _fts_open_b, '_fts_open_b$INODE64', 
-                       _fts_read, '_fts_read$INODE64', _fts_set, '_fts_set$INODE64', 
-                       _ftw, '_ftw$INODE64', _fungetrune, _funlockfile, _funopen, 
-                       _fwide, _fwprintf, _fwprintf_l, _fwrite, _fwscanf, _fwscanf_l, 
-                       _fxprintf, _fxprintf_exec, _gcvt, _getbsize, _getc, _getc_unlocked, 
-                       _getchar, _getchar_unlocked, _getcwd, _getdate, _getdate_err, 
-                       _getdelim, _getdiskbyname, _getenv, '_getgroups$DARWIN_EXTSN', 
-                       _gethostid, _gethostname, _getipv4sourcefilter, _getlastlogx, 
-                       _getlastlogxbyname, _getline, _getloadavg, _getlogin, _getlogin_r, 
-                       _getmntinfo, '_getmntinfo$INODE64', _getmntinfo64, _getmntinfo_r_np, 
-                       '_getmntinfo_r_np$INODE64', _getmode, _getopt, _getopt_long, 
-                       _getopt_long_only, _getpagesize, _getpass, _getpeereid, _getprogname, 
-                       _gets, _getsourcefilter, _getsubopt, _gettimeofday, _getttyent, 
-                       _getttynam, _getusershell, _getutmp, _getutmpx, _getutxent, 
-                       _getutxent_wtmp, _getutxid, _getutxline, _getvfsbyname, _getw, 
-                       _getwc, _getwc_l, _getwchar, _getwchar_l, _getwd, _glob, '_glob$INODE64', 
-                       _glob_b, '_glob_b$INODE64', _globfree, _gmtime, _gmtime_r, 
-                       _grantpt, _hash_create, _hash_destroy, _hash_purge, _hash_search, 
-                       _hash_stats, _hash_traverse, _hcreate, _hdestroy, _heapsort, 
-                       _heapsort_b, _hsearch, _imaxabs, _imaxdiv, _index, _inet_addr, 
-                       _inet_aton, _inet_lnaof, _inet_makeaddr, _inet_net_ntop, _inet_net_pton, 
-                       _inet_neta, _inet_netof, _inet_network, _inet_nsap_addr, _inet_nsap_ntoa, 
-                       _inet_ntoa, _inet_ntop, _inet_ntop4, _inet_ntop6, _inet_pton, 
-                       _initstate, _insque, _isalnum, _isalnum_l, _isalpha, _isalpha_l, 
-                       _isascii, _isatty, _isblank, _isblank_l, _iscntrl, _iscntrl_l, 
-                       _isdigit, _isdigit_l, _isgraph, _isgraph_l, _ishexnumber, 
-                       _ishexnumber_l, _isideogram, _isideogram_l, _islower, _islower_l, 
-                       _isnumber, _isnumber_l, _isphonogram, _isphonogram_l, _isprint, 
-                       _isprint_l, _ispunct, _ispunct_l, _isrune, _isrune_l, _isspace, 
-                       _isspace_l, _isspecial, _isspecial_l, _isupper, _isupper_l, 
-                       _iswalnum, _iswalnum_l, _iswalpha, _iswalpha_l, _iswascii, 
-                       _iswblank, _iswblank_l, _iswcntrl, _iswcntrl_l, _iswctype, 
-                       _iswctype_l, _iswdigit, _iswdigit_l, _iswgraph, _iswgraph_l, 
-                       _iswhexnumber, _iswhexnumber_l, _iswideogram, _iswideogram_l, 
-                       _iswlower, _iswlower_l, _iswnumber, _iswnumber_l, _iswphonogram, 
-                       _iswphonogram_l, _iswprint, _iswprint_l, _iswpunct, _iswpunct_l, 
-                       _iswrune, _iswrune_l, _iswspace, _iswspace_l, _iswspecial, 
-                       _iswspecial_l, _iswupper, _iswupper_l, _iswxdigit, _iswxdigit_l, 
-                       _isxdigit, _isxdigit_l, _jrand48, _kOSThermalNotificationPressureLevelName, 
-                       _killpg, _l64a, _labs, _lchflags, _lchmod, _lcong48, _ldiv, 
-                       _lfind, _link_addr, _link_ntoa, _llabs, _lldiv, _localeconv, 
-                       _localeconv_l, _localtime, _localtime_r, _lockf, '_lockf$NOCANCEL', 
-                       _login, _login_tty, _logout, _logwtmp, _lrand48, _lsearch, 
-                       _lstatx64_np, _lstatx_np, '_lstatx_np$INODE64', _lutimes, 
-                       _mblen, _mblen_l, _mbmb, _mbrlen, _mbrlen_l, _mbrrune, _mbrtowc, 
-                       _mbrtowc_l, _mbrune, _mbsinit, _mbsinit_l, _mbsnrtowcs, _mbsnrtowcs_l, 
-                       _mbsrtowcs, _mbsrtowcs_l, _mbstowcs, _mbstowcs_l, _mbtowc, 
-                       _mbtowc_l, _memccpy, _memchr, _memcmp, _memcpy, _memmem, _memmove, 
-                       _memset, _memset_pattern16, _memset_pattern4, _memset_pattern8, 
-                       _memset_s, _mergesort, _mergesort_b, _mkdirx_np, _mkdtemp, 
-                       _mkdtempat_np, _mkfifox_np, _mkostemp, _mkostemps, _mkostempsat_np, 
-                       _mkpath_np, _mkpathat_np, _mkstemp, _mkstemp_dprotected_np, 
-                       _mkstemps, _mkstempsat_np, _mktemp, _mktime, _monaddition, 
-                       _moncontrol, _moncount, _moninit, _monitor, _monoutput, _monreset, 
-                       _monstartup, _mpool_close, _mpool_filter, _mpool_get, _mpool_new, 
-                       _mpool_open, _mpool_put, _mpool_sync, _mrand48, _nanosleep, 
-                       '_nanosleep$NOCANCEL', _new_printf_comp, _new_printf_domain, 
-                       _newlocale, _nextwctype, _nextwctype_l, _nftw, '_nftw$INODE64', 
-                       _nice, _nl_langinfo, _nl_langinfo_l, _nrand48, _nvis, _off32, 
-                       _off64, _offtime, _open_memstream, _open_wmemstream, _opendev, 
-                       _opendir, '_opendir$INODE64', _openpty, _openx_np, _optarg, 
-                       _opterr, _optind, _optopt, _optreset, _pause, '_pause$NOCANCEL', 
-                       _pclose, _perror, _popen, '_popen$DARWIN_EXTSN', _posix2time, 
-                       _posix_openpt, _posix_spawnp, _printf, _printf_l, _psignal, 
-                       _psort, _psort_b, _psort_r, _ptsname, _ptsname_r, _putc, _putc_unlocked, 
-                       _putchar, _putchar_unlocked, _putenv, _puts, _pututxline, 
-                       _putw, _putwc, _putwc_l, _putwchar, _putwchar_l, _qsort, _qsort_b, 
-                       _qsort_r, _querylocale, _radixsort, _raise, _rand, _rand_r, 
-                       _random, _rb_tree_count, _rb_tree_find_node, _rb_tree_find_node_geq, 
-                       _rb_tree_find_node_leq, _rb_tree_init, _rb_tree_insert_node, 
-                       _rb_tree_iterate, _rb_tree_remove_node, _readdir, '_readdir$INODE64', 
-                       _readdir_r, '_readdir_r$INODE64', _readpassphrase, _reallocf, 
-                       _realpath, '_realpath$DARWIN_EXTSN', _recv, '_recv$NOCANCEL', 
-                       _regcomp, _regcomp_l, _regerror, _regexec, _regfree, _register_printf_domain_function, 
-                       _register_printf_domain_render_std, _regncomp, _regncomp_l, 
-                       _regnexec, _regwcomp, _regwcomp_l, _regwexec, _regwncomp, 
-                       _regwncomp_l, _regwnexec, _remove, _remque, _rewind, _rewinddir, 
-                       '_rewinddir$INODE64', _rindex, _rpmatch, _sbrk, _scandir, 
-                       '_scandir$INODE64', _scandir_b, '_scandir_b$INODE64', _scanf, 
-                       _scanf_l, _seed48, _seekdir, '_seekdir$INODE64', _send, '_send$NOCANCEL', 
-                       _setbuf, _setbuffer, _setenv, _sethostid, _sethostname, _setinvalidrune, 
-                       _setipv4sourcefilter, _setkey, _setlinebuf, _setlocale, _setlogin, 
-                       _setmode, _setpgrp, _setprogname, _setrgid, _setruid, _setrunelocale, 
-                       _setsourcefilter, _setstate, _settimeofday, _setttyent, _setusershell, 
-                       _setutxent, _setutxent_wtmp, _setvbuf, _sigaction, _sigaddset, 
-                       _sigaltstack, _sigblock, _sigdelset, _sigemptyset, _sigfillset, 
-                       _sighold, _sigignore, _siginterrupt, _sigismember, _signal, 
-                       _sigpause, '_sigpause$NOCANCEL', _sigrelse, _sigset, _sigsetmask, 
-                       _sigvec, _skip, _sl_add, _sl_find, _sl_free, _sl_init, _sleep, 
-                       '_sleep$NOCANCEL', _snprintf, _snprintf_l, _snvis, _sockatmark, 
-                       _sprintf, _sprintf_l, _sradixsort, _srand, _srand48, _sranddev, 
-                       _srandom, _srandomdev, _sscanf, _sscanf_l, _statvfs, _statx64_np, 
-                       _statx_np, '_statx_np$INODE64', _stpcpy, _stpncpy, _strcasecmp, 
-                       _strcasecmp_l, _strcasestr, _strcasestr_l, _strcat, _strchr, 
-                       _strcmp, _strcoll, _strcoll_l, _strcpy, _strcspn, _strdup, 
-                       _strenvisx, _strerror, _strerror_r, _strfmon, _strfmon_l, 
-                       _strftime, _strftime_l, _strlcat, _strlcpy, _strlen, _strmode, 
-                       _strncasecmp, _strncasecmp_l, _strncat, _strncmp, _strncpy, 
-                       _strndup, _strnlen, _strnstr, _strnunvis, _strnunvisx, _strnvis, 
-                       _strnvisx, _strpbrk, _strptime, _strptime_l, _strrchr, _strsenvisx, 
-                       _strsep, _strsignal, _strsnvis, _strsnvisx, _strspn, _strstr, 
-                       _strsvis, _strsvisx, _strtod, _strtod_l, _strtof, _strtof_l, 
-                       _strtofflags, _strtoimax, _strtoimax_l, _strtok, _strtok_r, 
-                       _strtol, _strtol_l, _strtold, _strtold_l, _strtoll, _strtoll_l, 
-                       _strtoq, _strtoq_l, _strtoul, _strtoul_l, _strtoull, _strtoull_l, 
-                       _strtoumax, _strtoumax_l, _strtouq, _strtouq_l, _strunvis, 
-                       _strunvisx, _strvis, _strvisx, _strxfrm, _strxfrm_l, _suboptarg, 
-                       _svis, _swab, _swprintf, _swprintf_l, _swscanf, _swscanf_l, 
-                       _sxprintf, _sxprintf_exec, _sync_volume_np, _sys_errlist, 
-                       _sys_nerr, _sys_siglist, _sys_signame, _sysconf, _sysctl, 
-                       _sysctlbyname, _sysctlnametomib, _system, '_system$NOCANCEL', 
-                       _tcdrain, '_tcdrain$NOCANCEL', _tcflow, _tcflush, _tcgetattr, 
-                       _tcgetpgrp, _tcgetsid, _tcsendbreak, _tcsetattr, _tcsetpgrp, 
-                       _tdelete, _telldir, '_telldir$INODE64', _tempnam, _tfind, 
-                       _thread_stack_pcs, _time, _time2posix, _timegm, _timelocal, 
-                       _timeoff, _times, _timespec_get, _timezone, _timingsafe_bcmp, 
-                       _tmpfile, _tmpnam, _toascii, _tolower, _tolower_l, _toupper, 
-                       _toupper_l, _towctrans, _towctrans_l, _towlower, _towlower_l, 
-                       _towupper, _towupper_l, _tre_ast_new_catenation, _tre_ast_new_iter, 
-                       _tre_ast_new_literal, _tre_ast_new_node, _tre_ast_new_union, 
-                       _tre_compile, _tre_fill_pmatch, _tre_free, _tre_mem_alloc_impl, 
-                       _tre_mem_destroy, _tre_mem_new_impl, _tre_parse, _tre_stack_destroy, 
-                       _tre_stack_new, _tre_stack_num_objects, _tre_tnfa_run_backtrack, 
-                       _tre_tnfa_run_parallel, _tsearch, _ttyname, _ttyname_r, _ttyslot, 
-                       _twalk, _tzname, _tzset, _tzsetwall, _ualarm, _ulimit, _umaskx_np, 
-                       _uname, _ungetc, _ungetwc, _ungetwc_l, _unlockpt, _unsetenv, 
-                       _unvis, _uselocale, _usleep, '_usleep$NOCANCEL', _utime, _utmpxname, 
-                       _uuid_clear, _uuid_compare, _uuid_copy, _uuid_generate, _uuid_generate_random, 
-                       _uuid_generate_time, _uuid_is_null, _uuid_pack, _uuid_parse, 
-                       _uuid_unpack, _uuid_unparse, _uuid_unparse_lower, _uuid_unparse_upper, 
-                       _vasprintf, _vasprintf_l, _vasxprintf, _vasxprintf_exec, _vdprintf, 
-                       _vdprintf_l, _vdxprintf, _vdxprintf_exec, _verr, _verrc, _verrx, 
-                       _vfprintf, _vfprintf_l, _vfscanf, _vfscanf_l, _vfwprintf, 
-                       _vfwprintf_l, _vfwscanf, _vfwscanf_l, _vfxprintf, _vfxprintf_exec, 
-                       _vis, _vprintf, _vprintf_l, _vscanf, _vscanf_l, _vsnprintf, 
-                       _vsnprintf_l, _vsprintf, _vsprintf_l, _vsscanf, _vsscanf_l, 
-                       _vswprintf, _vswprintf_l, _vswscanf, _vswscanf_l, _vsxprintf, 
-                       _vsxprintf_exec, _vwarn, _vwarnc, _vwarnx, _vwprintf, _vwprintf_l, 
-                       _vwscanf, _vwscanf_l, _vxprintf, _vxprintf_exec, _wait, '_wait$NOCANCEL', 
-                       _wait3, _waitpid, '_waitpid$NOCANCEL', _warn, _warnc, _warnx, 
-                       _wcpcpy, _wcpncpy, _wcrtomb, _wcrtomb_l, _wcscasecmp, _wcscasecmp_l, 
-                       _wcscat, _wcschr, _wcscmp, _wcscoll, _wcscoll_l, _wcscpy, 
-                       _wcscspn, _wcsdup, _wcsftime, _wcsftime_l, _wcslcat, _wcslcpy, 
-                       _wcslen, _wcsncasecmp, _wcsncasecmp_l, _wcsncat, _wcsncmp, 
-                       _wcsncpy, _wcsnlen, _wcsnrtombs, _wcsnrtombs_l, _wcspbrk, 
-                       _wcsrchr, _wcsrtombs, _wcsrtombs_l, _wcsspn, _wcsstr, _wcstod, 
-                       _wcstod_l, _wcstof, _wcstof_l, _wcstoimax, _wcstoimax_l, _wcstok, 
-                       _wcstol, _wcstol_l, _wcstold, _wcstold_l, _wcstoll, _wcstoll_l, 
-                       _wcstombs, _wcstombs_l, _wcstoul, _wcstoul_l, _wcstoull, _wcstoull_l, 
-                       _wcstoumax, _wcstoumax_l, _wcswidth, _wcswidth_l, _wcsxfrm, 
-                       _wcsxfrm_l, _wctob, _wctob_l, _wctomb, _wctomb_l, _wctrans, 
-                       _wctrans_l, _wctype, _wctype_l, _wcwidth, _wcwidth_l, _wmemchr, 
-                       _wmemcmp, _wmemcpy, _wmemmove, _wmemset, _wordexp, _wordfree, 
-                       _wprintf, _wprintf_l, _wscanf, _wscanf_l, _wtmpxname, _xprintf, 
-                       _xprintf_exec, mcount ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           0EE84C33-64FD-372B-974A-AF7A136F2068
-  - target:          x86_64-maccatalyst
-    value:           0EE84C33-64FD-372B-974A-AF7A136F2068
-install-name:    '/usr/lib/system/libsystem_configuration.dylib'
-current-version: 1061.141.1
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ __dns_configuration_ack, __libSC_info_fork_child, __libSC_info_fork_parent, 
-                       __libSC_info_fork_prepare, __nwi_config_agent_copy_data, __nwi_state_ack, 
-                       __nwi_state_force_refresh, _config_agent_copy_dns_information, 
-                       _config_agent_copy_proxy_information, _config_agent_free_dns_information, 
-                       _config_agent_free_proxy_information, _config_agent_get_dns_nameservers, 
-                       _config_agent_get_dns_searchdomains, _config_agent_update_proxy_information, 
-                       _dns_configuration_copy, _dns_configuration_free, _dns_configuration_notify_key, 
-                       _is_config_agent_type_dns, _is_config_agent_type_proxy, _nwi_ifstate_compare_rank, 
-                       _nwi_ifstate_get_dns_signature, _nwi_ifstate_get_flags, _nwi_ifstate_get_generation, 
-                       _nwi_ifstate_get_ifname, _nwi_ifstate_get_next, _nwi_ifstate_get_reachability_flags, 
-                       _nwi_ifstate_get_signature, _nwi_ifstate_get_vpn_server, _nwi_state_copy, 
-                       _nwi_state_get_first_ifstate, _nwi_state_get_generation, _nwi_state_get_ifstate, 
-                       _nwi_state_get_interface_names, _nwi_state_get_notify_key, 
-                       _nwi_state_get_reachability_flags, _nwi_state_release ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           A199156E-058D-3ABB-BCE9-4B9F20DCED0F
-  - target:          x86_64-maccatalyst
-    value:           A199156E-058D-3ABB-BCE9-4B9F20DCED0F
-install-name:    '/usr/lib/system/libsystem_coreservices.dylib'
-current-version: 114
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _NSGetNextSearchPathEnumeration, _NSStartSearchPathEnumeration, 
-                       _NSStartSearchPathEnumerationPrivate, ___user_local_dirname, 
-                       ___user_relative_dirname, __append_relative_path_component, 
-                       __dirhelper, __dirhelper_relative, __get_user_dir_suffix, 
-                       __libcoreservices_fork_child, __set_user_dir_suffix, _sysdir_get_next_search_path_enumeration, 
-                       _sysdir_start_search_path_enumeration, _sysdir_start_search_path_enumeration_private ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           5B12B5DB-3F30-37C1-8ECC-49A66B1F2864
-  - target:          x86_64-maccatalyst
-    value:           5B12B5DB-3F30-37C1-8ECC-49A66B1F2864
-install-name:    '/usr/lib/system/libsystem_darwin.dylib'
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ ___libdarwin_init, ___os_temporary_resource_shortage, _claimfd_np, 
-                       _close_drop_np, _close_drop_optional_np, _crfprintf_np, _dirstat_np, 
-                       _dirstatat_np, _dup_np, _err_np, _errc_np, _fcheck_np, _memdup2_np, 
-                       _memdup_np, _os_assert_mach, _os_assert_mach_port_status, 
-                       _os_crash_get_reporter_port_array, _os_crash_port_array_deallocate, 
-                       _os_crash_set_reporter_port, _os_crash_spawnattr_set_reporter_port, 
-                       _os_flagset_copy_string, _os_localtime_file, _os_mach_msg_copy_description, 
-                       _os_mach_msg_get_audit_trailer, _os_mach_msg_get_context_trailer, 
-                       _os_mach_msg_get_trailer, _os_mach_msg_trailer_copy_description, 
-                       _os_mach_port_copy_description, _os_parse_boot_arg_int, _os_parse_boot_arg_string, 
-                       _os_simple_hash, _os_simple_hash_string, _os_simple_hash_string_with_seed, 
-                       _os_simple_hash_with_seed, _os_subcommand_fprintf, _os_subcommand_main, 
-                       _os_subcommand_vfprintf, _os_variant_allows_internal_security_policies, 
-                       _os_variant_check, _os_variant_has_factory_content, _os_variant_has_internal_content, 
-                       _os_variant_has_internal_diagnostics, _os_variant_has_internal_ui, 
-                       _os_variant_is_darwinos, _os_variant_is_recovery, _os_variant_uses_ephemeral_storage, 
-                       _realpath_np, _strerror_np, _strexit_np, _symerror_np, _symexit_np, 
-                       _sysctl_get_data_np, _sysctlbyname_get_data_np, _sysexit_np, 
-                       _vcrfprintf_np, _verr_np, _verrc_np, _vwarn_np, _vwfprintf_np, 
-                       _warn_np, _wfprintf_np, _xferfd_np, _zsnprintf_np ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           EBB4C2C2-E031-3094-B40A-E67BF261D295
-  - target:          x86_64-maccatalyst
-    value:           EBB4C2C2-E031-3094-B40A-E67BF261D295
-install-name:    '/usr/lib/system/libsystem_dnssd.dylib'
-current-version: 1096.100.3
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _DNSServiceAddRecord, _DNSServiceBrowse, _DNSServiceBrowserCreate, 
-                       _DNSServiceConstructFullName, _DNSServiceCreateConnection, 
-                       _DNSServiceCreateDelegateConnection, _DNSServiceDiscoveryDeallocate, 
-                       _DNSServiceDiscoveryMachPort, _DNSServiceDiscovery_handleReply, 
-                       _DNSServiceEnumerateDomains, _DNSServiceGetAddrInfo, _DNSServiceGetPID, 
-                       _DNSServiceGetProperty, _DNSServiceNATPortMappingCreate, _DNSServiceProcessResult, 
-                       _DNSServiceQueryRecord, _DNSServiceReconfirmRecord, _DNSServiceRefDeallocate, 
-                       _DNSServiceRefSockFD, _DNSServiceRegister, _DNSServiceRegisterRecord, 
-                       _DNSServiceRemoveRecord, _DNSServiceResolve, _DNSServiceResolverResolve, 
-                       _DNSServiceSetDefaultDomainForUser, _DNSServiceSetDispatchQueue, 
-                       _DNSServiceSleepKeepalive, _DNSServiceSleepKeepalive_sockaddr, 
-                       _DNSServiceUpdateRecord, _PeerConnectionRelease, _TXTRecordContainsKey, 
-                       _TXTRecordCreate, _TXTRecordDeallocate, _TXTRecordGetBytesPtr, 
-                       _TXTRecordGetCount, _TXTRecordGetItemAtIndex, _TXTRecordGetLength, 
-                       _TXTRecordGetValuePtr, _TXTRecordRemoveValue, _TXTRecordSetValue ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           29FD922A-EC2C-3F25-BCCC-B58D716E60EC
-  - target:          x86_64-maccatalyst
-    value:           29FD922A-EC2C-3F25-BCCC-B58D716E60EC
-install-name:    '/usr/lib/system/libsystem_featureflags.dylib'
-current-version: 17
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ __os_feature_enabled_impl ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           8A321605-5480-330B-AF9E-64E65DE61747
-  - target:          x86_64-maccatalyst
-    value:           8A321605-5480-330B-AF9E-64E65DE61747
-install-name:    '/usr/lib/system/libsystem_info.dylib'
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _LI_get_thread_item, _LI_get_thread_list, _LI_ils_create, 
-                       _LI_set_thread_item, _LI_set_thread_list, ___dn_skipname, 
-                       __authenticate, __ds_running, __gai_nat64_can_v4_address_be_synthesized, 
-                       __gai_serv_to_port, __gai_simple, __getaddrinfo_interface_async_call, 
-                       __getlong, __getnameinfo_interface_async_call, __getshort, 
-                       __null_auth, __res, __seterr_reply, __si_disable_opendirectory, 
-                       __yp_dobind, _alias_endent, _alias_getbyname, _alias_getent, 
-                       _alias_setent, _authnone_create, _authunix_create, _authunix_create_default, 
-                       _bindresvport, _bindresvport_sa, _bootparams_endent, _bootparams_getbyname, 
-                       _bootparams_getent, _bootparams_setent, _clnt_broadcast, _clnt_create, 
-                       _clnt_pcreateerror, _clnt_perrno, _clnt_perror, _clnt_spcreateerror, 
-                       _clnt_sperrno, _clnt_sperror, _clntraw_create, _clnttcp_create, 
-                       _clntudp_bufcreate, _clntudp_create, _configuration_profile_copy_property_list, 
-                       _configuration_profile_create_notification_key, _dn_expand, 
-                       _endfsent, _endgrent, _endhostent, _endnetent, _endnetgrent, 
-                       _endprotoent, _endpwent, _endrpcent, _endservent, _ether_aton, 
-                       _ether_hostton, _ether_line, _ether_ntoa, _ether_ntohost, 
-                       _freeaddrinfo, _freehostent, _freeifaddrs, _freeifmaddrs, 
-                       _gL1CacheEnabled, _gai_strerror, _getaddrinfo, _getaddrinfo_async_cancel, 
-                       _getaddrinfo_async_handle_reply, _getaddrinfo_async_receive, 
-                       _getaddrinfo_async_send, _getaddrinfo_async_start, _getdomainname, 
-                       _getfsent, _getfsfile, _getfsspec, _getgrent, _getgrgid, _getgrgid_r, 
-                       _getgrnam, _getgrnam_r, _getgroupcount, _getgrouplist, _getgrouplist_2, 
-                       _getgruuid, _getgruuid_r, _gethostbyaddr, _gethostbyaddr_async_cancel, 
-                       _gethostbyaddr_async_handleReply, _gethostbyaddr_async_start, 
-                       _gethostbyname, _gethostbyname2, _gethostbyname_async_cancel, 
-                       _gethostbyname_async_handleReply, _gethostbyname_async_start, 
-                       _gethostent, _getifaddrs, _getifmaddrs, _getipnodebyaddr, 
-                       _getipnodebyname, _getnameinfo, _getnameinfo_async_cancel, 
-                       _getnameinfo_async_handle_reply, _getnameinfo_async_send, 
-                       _getnameinfo_async_start, _getnetbyaddr, _getnetbyname, _getnetent, 
-                       _getnetgrent, _getprotobyname, _getprotobynumber, _getprotoent, 
-                       _getpwent, _getpwnam, _getpwnam_r, _getpwuid, _getpwuid_r, 
-                       _getpwuuid, _getpwuuid_r, _getrpcbyname, _getrpcbynumber, 
-                       _getrpcent, _getrpcport, _getservbyname, _getservbyport, _getservent, 
-                       _group_from_gid, _h_errno, _herror, _hstrerror, _htonl, _htons, 
-                       _if_freenameindex, _if_indextoname, _if_nameindex, _if_nametoindex, 
-                       _in6addr_any, _in6addr_linklocal_allnodes, _in6addr_linklocal_allrouters, 
-                       _in6addr_linklocal_allv2routers, _in6addr_loopback, _in6addr_nodelocal_allnodes, 
-                       _inet6_opt_append, _inet6_opt_find, _inet6_opt_finish, _inet6_opt_get_val, 
-                       _inet6_opt_init, _inet6_opt_next, _inet6_opt_set_val, _inet6_option_alloc, 
-                       _inet6_option_append, _inet6_option_find, _inet6_option_init, 
-                       _inet6_option_next, _inet6_option_space, _inet6_rth_add, _inet6_rth_getaddr, 
-                       _inet6_rth_init, _inet6_rth_reverse, _inet6_rth_segments, 
-                       _inet6_rth_space, _inet6_rthdr_add, _inet6_rthdr_getaddr, 
-                       _inet6_rthdr_getflags, _inet6_rthdr_init, _inet6_rthdr_lasthop, 
-                       _inet6_rthdr_segments, _inet6_rthdr_space, _initgroups, _innetgr, 
-                       _iruserok, _iruserok_sa, _kvarray_free, _kvbuf_add_dict, _kvbuf_add_key, 
-                       _kvbuf_add_val, _kvbuf_add_val_len, _kvbuf_append_kvbuf, _kvbuf_decode, 
-                       _kvbuf_free, _kvbuf_get_len, _kvbuf_init, _kvbuf_init_zone, 
-                       _kvbuf_make_nonpurgeable, _kvbuf_make_purgeable, _kvbuf_new, 
-                       _kvbuf_new_zone, _kvbuf_next_dict, _kvbuf_next_key, _kvbuf_next_val, 
-                       _kvbuf_next_val_len, _kvbuf_query, _kvbuf_query_key_int, _kvbuf_query_key_uint, 
-                       _kvbuf_query_key_val, _kvbuf_reset, _mbr_check_membership, 
-                       _mbr_check_membership_by_id, _mbr_check_membership_ext, _mbr_check_membership_refresh, 
-                       _mbr_check_service_membership, _mbr_gid_to_uuid, _mbr_group_name_to_uuid, 
-                       _mbr_identifier_to_uuid, _mbr_identifier_translate, _mbr_reset_cache, 
-                       _mbr_set_identifier_ttl, _mbr_sid_to_string, _mbr_sid_to_uuid, 
-                       _mbr_string_to_sid, _mbr_string_to_uuid, _mbr_uid_to_uuid, 
-                       _mbr_user_name_to_uuid, _mbr_uuid_to_id, _mbr_uuid_to_sid, 
-                       _mbr_uuid_to_sid_type, _mbr_uuid_to_string, _ntohl, _ntohs, 
-                       _pmap_getmaps, _pmap_getport, _pmap_rmtcall, _pmap_set, _pmap_unset, 
-                       _prdb_end, _prdb_get, _prdb_getbyname, _prdb_set, _rcmd, _rcmd_af, 
-                       _res_init, _res_query, _res_search, _rpc_createerr, _rresvport, 
-                       _rresvport_af, _ruserok, _setdomainname, _setfsent, _setgrent, 
-                       _setgroupent, _sethostent, _setnetent, _setnetgrent, _setpassent, 
-                       _setprotoent, _setpwent, _setrpcent, _setservent, _si_addrinfo, 
-                       _si_addrinfo_list, _si_addrinfo_list_from_hostent, _si_addrinfo_v4, 
-                       _si_addrinfo_v4_mapped, _si_addrinfo_v6, _si_alias_all, _si_alias_byname, 
-                       _si_async_call, _si_async_cancel, _si_async_handle_reply, 
-                       _si_destination_compare, _si_destination_compare_no_dependencies, 
-                       _si_fs_all, _si_fs_byfile, _si_fs_byspec, _si_group_all, _si_group_bygid, 
-                       _si_group_byname, _si_group_byuuid, _si_grouplist, _si_host_all, 
-                       _si_host_byaddr, _si_host_byname, _si_in_netgroup, _si_ipnode_byname, 
-                       _si_item_call, _si_item_is_valid, _si_item_match, _si_item_release, 
-                       _si_item_retain, _si_list_add, _si_list_call, _si_list_concat, 
-                       _si_list_next, _si_list_release, _si_list_reset, _si_list_retain, 
-                       _si_mac_all, _si_mac_bymac, _si_mac_byname, _si_module_name, 
-                       _si_module_release, _si_module_retain, _si_module_vers, _si_module_with_name, 
-                       _si_nameinfo, _si_netgroup_byname, _si_network_all, _si_network_byaddr, 
-                       _si_network_byname, _si_protocol_all, _si_protocol_byname, 
-                       _si_protocol_bynumber, _si_rpc_all, _si_rpc_byname, _si_rpc_bynumber, 
-                       _si_search, _si_search_module_set_flags, _si_service_all, 
-                       _si_service_byname, _si_service_byport, _si_set_nat64_v4_requires_synthesis, 
-                       _si_set_nat64_v4_synthesize, _si_srv_byname, _si_standardize_mac_address, 
-                       _si_user_all, _si_user_byname, _si_user_byuid, _si_user_byuuid, 
-                       _si_wants_addrinfo, _svc_fdset, _svc_getreq, _svc_getreqset, 
-                       _svc_register, _svc_run, _svc_sendreply, _svc_unregister, 
-                       _svcerr_auth, _svcerr_decode, _svcerr_noproc, _svcerr_noprog, 
-                       _svcerr_progvers, _svcerr_systemerr, _svcerr_weakauth, _svcfd_create, 
-                       _svcraw_create, _svctcp_create, _svcudp_bufcreate, _svcudp_create, 
-                       _user_from_uid, _xdr_array, _xdr_authunix_parms, _xdr_bool, 
-                       _xdr_bytes, _xdr_callhdr, _xdr_callmsg, _xdr_char, _xdr_des_block, 
-                       _xdr_domainname, _xdr_double, _xdr_enum, _xdr_float, _xdr_free, 
-                       _xdr_hyper, _xdr_int, _xdr_int16_t, _xdr_int32_t, _xdr_int64_t, 
-                       _xdr_keydat, _xdr_long, _xdr_longlong_t, _xdr_mapname, _xdr_netobj, 
-                       _xdr_opaque, _xdr_peername, _xdr_pmap, _xdr_pmaplist, _xdr_pointer, 
-                       _xdr_reference, _xdr_replymsg, _xdr_rmtcall_args, _xdr_rmtcallres, 
-                       _xdr_short, _xdr_string, _xdr_u_char, _xdr_u_hyper, _xdr_u_int, 
-                       _xdr_u_int16_t, _xdr_u_int32_t, _xdr_u_int64_t, _xdr_u_long, 
-                       _xdr_u_longlong_t, _xdr_u_short, _xdr_union, _xdr_valdat, 
-                       _xdr_vector, _xdr_void, _xdr_wrapstring, _xdr_x_passwd, _xdr_ypbind_binding, 
-                       _xdr_ypbind_resp, _xdr_ypbind_resptype, _xdr_ypbind_setdom, 
-                       _xdr_ypmaplist, _xdr_yppasswd, _xdr_ypreq_key, _xdr_ypreq_nokey, 
-                       _xdr_ypresp_all, _xdr_ypresp_all_seq, _xdr_ypresp_key_val, 
-                       _xdr_ypresp_maplist, _xdr_ypresp_master, _xdr_ypresp_order, 
-                       _xdr_ypresp_val, _xdr_ypstat, _xdrmem_create, _xdrrec_create, 
-                       _xdrrec_endofrecord, _xdrrec_eof, _xdrrec_skiprecord, _xdrstdio_create, 
-                       _xprt_register, _xprt_unregister, _yp_all, _yp_bind, _yp_first, 
-                       _yp_get_default_domain, _yp_maplist, _yp_master, _yp_match, 
-                       _yp_next, _yp_order, _yp_unbind, _yperr_string, _ypprot_err ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           2B6311E6-6240-3EF7-8C87-475B66F7452C
-  - target:          x86_64-maccatalyst
-    value:           2B6311E6-6240-3EF7-8C87-475B66F7452C
-install-name:    '/usr/lib/system/libsystem_kernel.dylib'
-current-version: 6153.141.1
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _NDR_record, _____old_semwait_signal_nocancel, _____sigwait_nocancel, 
-                       ____kernelVersionNumber, ____kernelVersionString, ___abort_with_payload, 
-                       ___accept, ___accept_nocancel, ___access_extended, ___aio_suspend_nocancel, 
-                       ___bind, ___bsdthread_create, ___bsdthread_ctl, ___bsdthread_register, 
-                       ___bsdthread_terminate, ___carbon_delete, ___channel_get_info, 
-                       ___channel_get_opt, ___channel_open, ___channel_set_opt, ___channel_sync, 
-                       ___chmod, ___chmod_extended, ___close_nocancel, ___coalition, 
-                       ___coalition_info, ___coalition_ledger, ___commpage_gettimeofday, 
-                       ___connect, ___connect_nocancel, ___copyfile, ___csrctl, ___darwin_check_fd_set_overflow, 
-                       ___delete, ___disable_threadsignal, ___error, ___exit, ___fchmod, 
-                       ___fchmod_extended, ___fcntl, ___fcntl_nocancel, ___fork, 
-                       ___fs_snapshot, ___fstat64_extended, ___fstat_extended, ___fsync_nocancel, 
-                       ___get_remove_counter, ___getattrlist, ___getdirentries64, 
-                       ___gethostuuid, ___getlogin, ___getpeername, ___getpid, ___getrlimit, 
-                       ___getsgroups, ___getsockname, ___gettid, ___gettimeofday, 
-                       ___getwgroups, ___guarded_open_dprotected_np, ___guarded_open_np, 
-                       ___identitysvc, ___inc_remove_counter, ___initgroups, ___ioctl, 
-                       ___iopolicysys, ___kdebug_trace, ___kdebug_trace64, ___kdebug_trace_string, 
-                       ___kdebug_typefilter, ___kill, ___kqueue_workloop_ctl, ___lchown, 
-                       ___libkernel_init, ___libkernel_platform_init, ___libkernel_voucher_init, 
-                       ___listen, ___log_data, ___lseek, ___lstat64_extended, ___lstat_extended, 
-                       ___mac_execve, ___mac_get_fd, ___mac_get_file, ___mac_get_link, 
-                       ___mac_get_mount, ___mac_get_pid, ___mac_get_proc, ___mac_getfsstat, 
-                       ___mac_mount, ___mac_set_fd, ___mac_set_file, ___mac_set_link, 
-                       ___mac_set_proc, ___mac_syscall, ___mach_bridge_remote_time, 
-                       ___memorystatus_available_memory, ___microstackshot, ___mkdir_extended, 
-                       ___mkfifo_extended, ___mmap, ___mprotect, ___msgctl, ___msgrcv_nocancel, 
-                       ___msgsnd_nocancel, ___msgsys, ___msync, ___msync_nocancel, 
-                       ___munmap, ___nexus_create, ___nexus_deregister, ___nexus_destroy, 
-                       ___nexus_get_opt, ___nexus_open, ___nexus_register, ___nexus_set_opt, 
-                       ___old_semwait_signal, ___open, ___open_dprotected_np, ___open_extended, 
-                       ___open_nocancel, ___openat, ___openat_nocancel, ___os_nexus_flow_add, 
-                       ___os_nexus_flow_del, ___os_nexus_ifattach, ___os_nexus_ifdetach, 
-                       ___persona, ___pipe, ___poll_nocancel, ___posix_spawn, ___pread_nocancel, 
-                       ___proc_info, ___process_policy, ___pselect, ___pselect_nocancel, 
-                       ___psynch_cvbroad, ___psynch_cvclrprepost, ___psynch_cvsignal, 
-                       ___psynch_cvwait, ___psynch_mutexdrop, ___psynch_mutexwait, 
-                       ___psynch_rw_downgrade, ___psynch_rw_longrdlock, ___psynch_rw_rdlock, 
-                       ___psynch_rw_unlock, ___psynch_rw_unlock2, ___psynch_rw_upgrade, 
-                       ___psynch_rw_wrlock, ___psynch_rw_yieldwrlock, ___pthread_canceled, 
-                       ___pthread_chdir, ___pthread_fchdir, ___pthread_kill, ___pthread_markcancel, 
-                       ___pthread_sigmask, ___ptrace, ___pwrite_nocancel, ___read_nocancel, 
-                       ___readv_nocancel, ___reboot, ___recvfrom, ___recvfrom_nocancel, 
-                       ___recvmsg, ___recvmsg_nocancel, ___rename, ___renameat, ___renameatx_np, 
-                       ___rmdir, ___sandbox_me, ___sandbox_mm, ___sandbox_ms, ___sandbox_msp, 
-                       ___select, ___select_nocancel, ___sem_open, ___sem_wait_nocancel, 
-                       ___semctl, ___semsys, ___semwait_signal, ___semwait_signal_nocancel, 
-                       ___sendmsg, ___sendmsg_nocancel, ___sendto, ___sendto_nocancel, 
-                       ___setattrlist, ___setlogin, ___setpriority, ___setregid, 
-                       ___setreuid, ___setrlimit, ___setsgroups, ___settid, ___settid_with_pid, 
-                       ___settimeofday, ___setwgroups, ___sfi_ctl, ___sfi_pidctl, 
-                       ___shared_region_check_np, ___shared_region_map_and_slide_np, 
-                       ___shm_open, ___shmctl, ___shmsys, ___sigaction, ___sigaltstack, 
-                       ___sigreturn, ___sigsuspend, ___sigsuspend_nocancel, ___sigwait, 
-                       ___socketpair, ___stack_snapshot_with_config, ___stat64_extended, 
-                       ___stat_extended, ___syscall, ___syscall_logger, ___sysctl, 
-                       ___sysctlbyname, ___telemetry, ___terminate_with_payload, 
-                       ___thread_selfid, ___thread_selfusage, ___ulock_wait, ___ulock_wake, 
-                       ___umask_extended, ___unlink, ___unlinkat, ___vfork, ___wait4, 
-                       ___wait4_nocancel, ___waitid_nocancel, ___work_interval_ctl, 
-                       ___workq_kernreturn, ___workq_open, ___write_nocancel, ___writev_nocancel, 
-                       __cpu_capabilities, __cpu_has_altivec, __exit, __get_cpu_capabilities, 
-                       __getprivatesystemidentifier, __host_page_size, __init_cpu_capabilities, 
-                       __kernelrpc_host_create_mach_voucher, __kernelrpc_mach_port_allocate, 
-                       __kernelrpc_mach_port_allocate_full, __kernelrpc_mach_port_allocate_name, 
-                       __kernelrpc_mach_port_allocate_qos, __kernelrpc_mach_port_allocate_trap, 
-                       __kernelrpc_mach_port_construct, __kernelrpc_mach_port_construct_trap, 
-                       __kernelrpc_mach_port_deallocate, __kernelrpc_mach_port_deallocate_trap, 
-                       __kernelrpc_mach_port_destroy, __kernelrpc_mach_port_destroy_trap, 
-                       __kernelrpc_mach_port_destruct, __kernelrpc_mach_port_destruct_trap, 
-                       __kernelrpc_mach_port_dnrequest_info, __kernelrpc_mach_port_extract_member, 
-                       __kernelrpc_mach_port_extract_member_trap, __kernelrpc_mach_port_extract_right, 
-                       __kernelrpc_mach_port_get_attributes, __kernelrpc_mach_port_get_attributes_trap, 
-                       __kernelrpc_mach_port_get_context, __kernelrpc_mach_port_get_refs, 
-                       __kernelrpc_mach_port_get_set_status, __kernelrpc_mach_port_get_srights, 
-                       __kernelrpc_mach_port_guard, __kernelrpc_mach_port_guard_trap, 
-                       __kernelrpc_mach_port_guard_with_flags, __kernelrpc_mach_port_insert_member, 
-                       __kernelrpc_mach_port_insert_member_trap, __kernelrpc_mach_port_insert_right, 
-                       __kernelrpc_mach_port_insert_right_trap, __kernelrpc_mach_port_kernel_object, 
-                       __kernelrpc_mach_port_kobject, __kernelrpc_mach_port_kobject_description, 
-                       __kernelrpc_mach_port_mod_refs, __kernelrpc_mach_port_mod_refs_trap, 
-                       __kernelrpc_mach_port_move_member, __kernelrpc_mach_port_move_member_trap, 
-                       __kernelrpc_mach_port_names, __kernelrpc_mach_port_peek, __kernelrpc_mach_port_rename, 
-                       __kernelrpc_mach_port_request_notification, __kernelrpc_mach_port_request_notification_trap, 
-                       __kernelrpc_mach_port_set_attributes, __kernelrpc_mach_port_set_context, 
-                       __kernelrpc_mach_port_set_mscount, __kernelrpc_mach_port_set_seqno, 
-                       __kernelrpc_mach_port_space_basic_info, __kernelrpc_mach_port_space_info, 
-                       __kernelrpc_mach_port_special_reply_port_reset_link, __kernelrpc_mach_port_swap_guard, 
-                       __kernelrpc_mach_port_type, __kernelrpc_mach_port_type_trap, 
-                       __kernelrpc_mach_port_unguard, __kernelrpc_mach_port_unguard_trap, 
-                       __kernelrpc_mach_vm_allocate, __kernelrpc_mach_vm_allocate_trap, 
-                       __kernelrpc_mach_vm_deallocate, __kernelrpc_mach_vm_deallocate_trap, 
-                       __kernelrpc_mach_vm_map, __kernelrpc_mach_vm_map_trap, __kernelrpc_mach_vm_protect, 
-                       __kernelrpc_mach_vm_protect_trap, __kernelrpc_mach_vm_purgable_control, 
-                       __kernelrpc_mach_vm_purgable_control_trap, __kernelrpc_mach_vm_read, 
-                       __kernelrpc_mach_vm_remap, __kernelrpc_mach_voucher_extract_attr_recipe, 
-                       __kernelrpc_task_set_port_space, __kernelrpc_thread_policy, 
-                       __kernelrpc_thread_policy_set, __kernelrpc_thread_set_policy, 
-                       __kernelrpc_vm_map, __kernelrpc_vm_purgable_control, __kernelrpc_vm_read, 
-                       __kernelrpc_vm_remap, __mach_errors, __mach_fork_child, __mach_snprintf, 
-                       __mach_vsnprintf, __os_alloc_once_table, __os_xbs_chrooted, 
-                       __register_gethostuuid_callback, __thread_set_tsd_base, _abort_with_payload, 
-                       _abort_with_reason, _accept, '_accept$NOCANCEL', _access, 
-                       _accessx_np, _acct, _act_get_state, _act_set_state, _adjtime, 
-                       _aio_cancel, _aio_error, _aio_fsync, _aio_read, _aio_return, 
-                       _aio_suspend, '_aio_suspend$NOCANCEL', _aio_write, _audit, 
-                       _audit_session_join, _audit_session_port, _audit_session_self, 
-                       _auditctl, _auditon, _bind, _bootstrap_port, _cerror, _cerror_nocancel, 
-                       _change_fdguard_np, _chdir, _chflags, _chmod, _chown, _chroot, 
-                       _clock_alarm, _clock_alarm_reply, _clock_get_attributes, _clock_get_time, 
-                       _clock_set_attributes, _clock_set_time, _clock_sleep, _clock_sleep_trap, 
-                       _clonefile, _clonefileat, _close, '_close$NOCANCEL', _coalition_create, 
-                       _coalition_info_resource_usage, _coalition_info_set_efficiency, 
-                       _coalition_info_set_name, _coalition_ledger_set_logical_writes_limit, 
-                       _coalition_reap, _coalition_terminate, _connect, '_connect$NOCANCEL', 
-                       _connectx, _csops, _csops_audittoken, _csr_check, _csr_get_active_config, 
-                       _debug_control_port_for_pid, _denap_boost_assertion_token, 
-                       _disconnectx, _dup, _dup2, _errno, _etap_trace_thread, _exc_server, 
-                       _exc_server_routine, _exception_raise, _exception_raise_state, 
-                       _exception_raise_state_identity, _exchangedata, _execve, _faccessat, 
-                       _fchdir, _fchflags, _fchmod, _fchmodat, _fchown, _fchownat, 
-                       _fclonefileat, _fcntl, '_fcntl$NOCANCEL', _fdatasync, _ffsctl, 
-                       _fgetattrlist, _fgetxattr, _fhopen, _fileport_makefd, _fileport_makeport, 
-                       _flistxattr, _flock, _fmount, _fpathconf, _fremovexattr, _fs_snapshot_create, 
-                       _fs_snapshot_delete, _fs_snapshot_list, _fs_snapshot_mount, 
-                       _fs_snapshot_rename, _fs_snapshot_revert, _fs_snapshot_root, 
-                       _fsctl, _fsetattrlist, _fsetxattr, _fsgetpath, _fsgetpath_ext, 
-                       _fstat, '_fstat$INODE64', _fstat64, _fstatat, '_fstatat$INODE64', 
-                       _fstatat64, _fstatfs, '_fstatfs$INODE64', _fstatfs64, _fsync, 
-                       '_fsync$NOCANCEL', _ftruncate, _futimens, _futimes, _getattrlist, 
-                       _getattrlistat, _getattrlistbulk, _getaudit, _getaudit_addr, 
-                       _getauid, _getdirentries, _getdirentriesattr, _getdtablesize, 
-                       _getegid, _getentropy, _geteuid, _getfh, _getfsstat, '_getfsstat$INODE64', 
-                       _getfsstat64, _getgid, _getgroups, _gethostuuid, _getiopolicy_np, 
-                       _getitimer, _getpeername, _getpgid, _getpgrp, _getpid, _getppid, 
-                       _getpriority, _getrlimit, _getrusage, _getsgroups_np, _getsid, 
-                       _getsockname, _getsockopt, _getuid, _getwgroups_np, _getxattr, 
-                       _grab_pgo_data, _guarded_close_np, _guarded_kqueue_np, _guarded_open_dprotected_np, 
-                       _guarded_open_np, _guarded_pwrite_np, _guarded_write_np, _guarded_writev_np, 
-                       _host_check_multiuser_mode, _host_create_mach_voucher, _host_create_mach_voucher_trap, 
-                       _host_default_memory_manager, _host_get_UNDServer, _host_get_atm_diagnostic_flag, 
-                       _host_get_boot_info, _host_get_clock_control, _host_get_clock_service, 
-                       _host_get_exception_ports, _host_get_io_master, _host_get_multiuser_config_flags, 
-                       _host_get_special_port, _host_info, _host_kernel_version, 
-                       _host_lockgroup_info, _host_page_size, _host_priv_statistics, 
-                       _host_processor_info, _host_processor_set_priv, _host_processor_sets, 
-                       _host_processors, _host_reboot, _host_register_mach_voucher_attr_manager, 
-                       _host_register_well_known_mach_voucher_attr_manager, _host_request_notification, 
-                       _host_security_create_task_token, _host_security_set_task_token, 
-                       _host_self, _host_self_trap, _host_set_UNDServer, _host_set_atm_diagnostic_flag, 
-                       _host_set_exception_ports, _host_set_multiuser_config_flags, 
-                       _host_set_special_port, _host_statistics, _host_statistics64, 
-                       _host_swap_exception_ports, _host_virtual_physical_table_info, 
-                       _i386_get_ldt, _i386_set_ldt, _important_boost_assertion_token, 
-                       _internal_catch_exc_subsystem, _ioctl, _issetugid, _kas_info, 
-                       _kdebug_is_enabled, _kdebug_signpost, _kdebug_signpost_end, 
-                       _kdebug_signpost_start, _kdebug_trace, _kdebug_trace_string, 
-                       _kdebug_typefilter, _kdebug_using_continuous_time, _kevent, 
-                       _kevent64, _kevent_id, _kevent_qos, _kext_request, _kill, 
-                       _kmod_control, _kmod_create, _kmod_destroy, _kmod_get_info, 
-                       _kpersona_alloc, _kpersona_dealloc, _kpersona_find, _kpersona_find_by_type, 
-                       _kpersona_get, _kpersona_getpath, _kpersona_info, _kpersona_palloc, 
-                       _kpersona_pidinfo, _kqueue, _lchown, _ledger, _link, _linkat, 
-                       _lio_listio, _listen, _listxattr, _lock_acquire, _lock_handoff, 
-                       _lock_handoff_accept, _lock_make_stable, _lock_release, _lock_set_create, 
-                       _lock_set_destroy, _lock_try, _log_data_as_kernel, _lseek, 
-                       _lstat, '_lstat$INODE64', _lstat64, _mach_absolute_time, _mach_approximate_time, 
-                       _mach_boottime_usec, _mach_continuous_approximate_time, _mach_continuous_time, 
-                       _mach_error, _mach_error_full_diag, _mach_error_string, _mach_error_type, 
-                       _mach_generate_activity_id, _mach_get_times, _mach_host_self, 
-                       _mach_host_special_port_description, _mach_host_special_port_for_id, 
-                       _mach_init, _mach_make_memory_entry, _mach_make_memory_entry_64, 
-                       _mach_memory_entry_access_tracking, _mach_memory_entry_ownership, 
-                       _mach_memory_entry_purgable_control, _mach_memory_info, _mach_memory_object_memory_entry, 
-                       _mach_memory_object_memory_entry_64, _mach_msg, _mach_msg_destroy, 
-                       _mach_msg_overwrite, _mach_msg_overwrite_trap, _mach_msg_receive, 
-                       _mach_msg_send, _mach_msg_server, _mach_msg_server_importance, 
-                       _mach_msg_server_once, _mach_msg_trap, _mach_notify_dead_name, 
-                       _mach_notify_no_senders, _mach_notify_port_deleted, _mach_notify_port_destroyed, 
-                       _mach_notify_send_once, _mach_port_allocate, _mach_port_allocate_full, 
-                       _mach_port_allocate_name, _mach_port_allocate_qos, _mach_port_construct, 
-                       _mach_port_deallocate, _mach_port_destroy, _mach_port_destruct, 
-                       _mach_port_dnrequest_info, _mach_port_extract_member, _mach_port_extract_right, 
-                       _mach_port_get_attributes, _mach_port_get_context, _mach_port_get_refs, 
-                       _mach_port_get_set_status, _mach_port_get_srights, _mach_port_guard, 
-                       _mach_port_guard_with_flags, _mach_port_insert_member, _mach_port_insert_right, 
-                       _mach_port_kernel_object, _mach_port_kobject, _mach_port_kobject_description, 
-                       _mach_port_mod_refs, _mach_port_move_member, _mach_port_names, 
-                       _mach_port_peek, _mach_port_rename, _mach_port_request_notification, 
-                       _mach_port_set_attributes, _mach_port_set_context, _mach_port_set_mscount, 
-                       _mach_port_set_seqno, _mach_port_space_basic_info, _mach_port_space_info, 
-                       _mach_port_swap_guard, _mach_port_type, _mach_port_unguard, 
-                       _mach_ports_lookup, _mach_ports_register, _mach_reply_port, 
-                       _mach_right_recv_construct, _mach_right_recv_destruct, _mach_right_send_create, 
-                       _mach_right_send_once_consume, _mach_right_send_once_create, 
-                       _mach_right_send_release, _mach_right_send_retain, _mach_sync_ipc_link_monitoring_start, 
-                       _mach_sync_ipc_link_monitoring_stop, _mach_task_self, _mach_task_self_, 
-                       _mach_task_special_port_description, _mach_task_special_port_for_id, 
-                       _mach_thread_self, _mach_timebase_info, _mach_timebase_info_trap, 
-                       _mach_vm_allocate, _mach_vm_behavior_set, _mach_vm_copy, _mach_vm_deallocate, 
-                       _mach_vm_inherit, _mach_vm_machine_attribute, _mach_vm_map, 
-                       _mach_vm_msync, _mach_vm_page_info, _mach_vm_page_query, _mach_vm_page_range_query, 
-                       _mach_vm_protect, _mach_vm_purgable_control, _mach_vm_read, 
-                       _mach_vm_read_list, _mach_vm_read_overwrite, _mach_vm_region, 
-                       _mach_vm_region_recurse, _mach_vm_remap, _mach_vm_wire, _mach_vm_write, 
-                       _mach_voucher_attr_command, _mach_voucher_deallocate, _mach_voucher_debug_info, 
-                       _mach_voucher_extract_all_attr_recipes, _mach_voucher_extract_attr_content, 
-                       _mach_voucher_extract_attr_recipe, _mach_voucher_extract_attr_recipe_trap, 
-                       _mach_wait_until, _mach_zone_force_gc, _mach_zone_get_btlog_records, 
-                       _mach_zone_get_zlog_zones, _mach_zone_info, _mach_zone_info_for_largest_zone, 
-                       _mach_zone_info_for_zone, _macx_backing_store_recovery, _macx_backing_store_suspend, 
-                       _macx_swapoff, _macx_swapon, _macx_triggers, _madvise, _memorystatus_control, 
-                       _memorystatus_get_level, _mig_allocate, _mig_dealloc_reply_port, 
-                       _mig_dealloc_special_reply_port, _mig_deallocate, _mig_get_reply_port, 
-                       _mig_get_special_reply_port, _mig_put_reply_port, _mig_reply_setup, 
-                       _mig_strncpy, _mig_strncpy_zerofill, _mincore, _minherit, 
-                       _mk_timer_arm, _mk_timer_arm_leeway, _mk_timer_cancel, _mk_timer_create, 
-                       _mk_timer_destroy, _mkdir, _mkdirat, _mkfifo, _mknod, _mlock, 
-                       _mlockall, _mmap, _modwatch, _mount, _mprotect, _mremap_encrypted, 
-                       _msg_receive, _msg_rpc, _msg_send, _msgctl, _msgget, _msgrcv, 
-                       '_msgrcv$NOCANCEL', _msgsnd, '_msgsnd$NOCANCEL', _msgsys, 
-                       _msync, '_msync$NOCANCEL', _munlock, _munlockall, _munmap, 
-                       _necp_client_action, _necp_match_policy, _necp_open, _necp_session_action, 
-                       _necp_session_open, _net_qos_guideline, _netagent_trigger, 
-                       _netname_check_in, _netname_check_out, _netname_look_up, _netname_version, 
-                       _nfsclnt, _nfssvc, _non_boost_assertion_token, _normal_boost_assertion_token, 
-                       _ntp_adjtime, _ntp_gettime, _open, '_open$NOCANCEL', _open_dprotected_np, 
-                       _openat, '_openat$NOCANCEL', _openbyid_np, _os_buflet_get_data_length, 
-                       _os_buflet_get_data_limit, _os_buflet_get_data_offset, _os_buflet_get_object_address, 
-                       _os_buflet_set_data_length, _os_buflet_set_data_offset, _os_channel_advance_slot, 
-                       _os_channel_attr_clone, _os_channel_attr_create, _os_channel_attr_destroy, 
-                       _os_channel_attr_get, _os_channel_attr_get_key, _os_channel_attr_set, 
-                       _os_channel_attr_set_key, _os_channel_available_slot_count, 
-                       _os_channel_configure_interface_advisory, _os_channel_create, 
-                       _os_channel_create_extended, _os_channel_destroy, _os_channel_event_free, 
-                       _os_channel_event_get_event_data, _os_channel_event_get_next_event, 
-                       _os_channel_flow_admissible, _os_channel_get_advisory_region, 
-                       _os_channel_get_fd, _os_channel_get_interface_advisory, _os_channel_get_next_event_handle, 
-                       _os_channel_get_next_slot, _os_channel_get_stats_region, _os_channel_is_defunct, 
-                       _os_channel_packet_alloc, _os_channel_packet_free, _os_channel_packet_pool_purge, 
-                       _os_channel_pending, _os_channel_read_attr, _os_channel_read_nexus_extension_info, 
-                       _os_channel_ring_id, _os_channel_ring_notify_time, _os_channel_ring_sync_time, 
-                       _os_channel_rx_ring, _os_channel_set_slot_properties, _os_channel_slot_attach_packet, 
-                       _os_channel_slot_detach_packet, _os_channel_slot_get_packet, 
-                       _os_channel_sync, _os_channel_tx_ring, _os_channel_write_attr, 
-                       _os_copy_and_inet_checksum, _os_cpu_copy_in_cksum, _os_cpu_in_cksum, 
-                       _os_cpu_in_cksum_mbuf, _os_fault_with_payload, _os_inet_checksum, 
-                       _os_nexus_attr_clone, _os_nexus_attr_create, _os_nexus_attr_destroy, 
-                       _os_nexus_attr_get, _os_nexus_attr_set, _os_nexus_controller_alloc_provider_instance, 
-                       _os_nexus_controller_bind_provider_instance, _os_nexus_controller_create, 
-                       _os_nexus_controller_deregister_provider, _os_nexus_controller_destroy, 
-                       _os_nexus_controller_free_provider_instance, _os_nexus_controller_get_fd, 
-                       _os_nexus_controller_read_provider_attr, _os_nexus_controller_register_provider, 
-                       _os_nexus_controller_unbind_provider_instance, _os_packet_clear_flow_uuid, 
-                       _os_packet_finalize, _os_packet_get_buflet_count, _os_packet_get_data_length, 
-                       _os_packet_get_expire_time, _os_packet_get_flow_uuid, _os_packet_get_group_end, 
-                       _os_packet_get_group_start, _os_packet_get_headroom, _os_packet_get_inet_checksum, 
-                       _os_packet_get_link_broadcast, _os_packet_get_link_ethfcs, 
-                       _os_packet_get_link_header_length, _os_packet_get_link_multicast, 
-                       _os_packet_get_next_buflet, _os_packet_get_packetid, _os_packet_get_service_class, 
-                       _os_packet_get_token, _os_packet_get_traffic_class, _os_packet_get_transport_retransmit, 
-                       _os_packet_get_transport_traffic_background, _os_packet_get_transport_traffic_realtime, 
-                       _os_packet_get_truncated, _os_packet_get_vlan_id, _os_packet_get_vlan_priority, 
-                       _os_packet_get_vlan_tag, _os_packet_set_expire_time, _os_packet_set_flow_uuid, 
-                       _os_packet_set_group_end, _os_packet_set_group_start, _os_packet_set_headroom, 
-                       _os_packet_set_inet_checksum, _os_packet_set_link_broadcast, 
-                       _os_packet_set_link_ethfcs, _os_packet_set_link_header_length, 
-                       _os_packet_set_link_multicast, _os_packet_set_packetid, _os_packet_set_service_class, 
-                       _os_packet_set_token, _os_packet_set_traffic_class, _os_packet_set_transport_last_packet, 
-                       _os_packet_set_transport_retransmit, _os_packet_set_transport_traffic_background, 
-                       _os_packet_set_transport_traffic_realtime, _os_packet_set_vlan_tag, 
-                       _panic, _panic_init, _pathconf, _peeloff, _pid_for_task, _pid_hibernate, 
-                       _pid_resume, _pid_shutdown_networking, _pid_shutdown_sockets, 
-                       _pid_suspend, _pipe, _pkt_subtype_assert_fail, _pkt_type_assert_fail, 
-                       _poll, '_poll$NOCANCEL', _port_obj_init, _port_obj_table, 
-                       _port_obj_table_size, _posix_madvise, _posix_spawn, _posix_spawn_file_actions_add_fileportdup2_np, 
-                       _posix_spawn_file_actions_addchdir_np, _posix_spawn_file_actions_addclose, 
-                       _posix_spawn_file_actions_adddup2, _posix_spawn_file_actions_addfchdir_np, 
-                       _posix_spawn_file_actions_addinherit_np, _posix_spawn_file_actions_addopen, 
-                       _posix_spawn_file_actions_destroy, _posix_spawn_file_actions_init, 
-                       _posix_spawnattr_destroy, _posix_spawnattr_get_darwin_role_np, 
-                       _posix_spawnattr_get_qos_clamp_np, _posix_spawnattr_getbinpref_np, 
-                       _posix_spawnattr_getcpumonitor, _posix_spawnattr_getflags, 
-                       _posix_spawnattr_getmacpolicyinfo_np, _posix_spawnattr_getpcontrol_np, 
-                       _posix_spawnattr_getpgroup, _posix_spawnattr_getprocesstype_np, 
-                       _posix_spawnattr_getsigdefault, _posix_spawnattr_getsigmask, 
-                       _posix_spawnattr_init, _posix_spawnattr_set_darwin_role_np, 
-                       _posix_spawnattr_set_gid_np, _posix_spawnattr_set_groups_np, 
-                       _posix_spawnattr_set_importancewatch_port_np, _posix_spawnattr_set_jetsam_ttr_np, 
-                       _posix_spawnattr_set_login_np, _posix_spawnattr_set_max_addr_np, 
-                       _posix_spawnattr_set_persona_gid_np, _posix_spawnattr_set_persona_groups_np, 
-                       _posix_spawnattr_set_persona_np, _posix_spawnattr_set_persona_uid_np, 
-                       _posix_spawnattr_set_qos_clamp_np, _posix_spawnattr_set_registered_ports_np, 
-                       _posix_spawnattr_set_threadlimit_ext, _posix_spawnattr_set_uid_np, 
-                       _posix_spawnattr_setauditsessionport_np, _posix_spawnattr_setbinpref_np, 
-                       _posix_spawnattr_setcoalition_np, _posix_spawnattr_setcpumonitor, 
-                       _posix_spawnattr_setcpumonitor_default, _posix_spawnattr_setexceptionports_np, 
-                       _posix_spawnattr_setflags, _posix_spawnattr_setjetsam_ext, 
-                       _posix_spawnattr_setmacpolicyinfo_np, _posix_spawnattr_setpcontrol_np, 
-                       _posix_spawnattr_setpgroup, _posix_spawnattr_setprocesstype_np, 
-                       _posix_spawnattr_setsigdefault, _posix_spawnattr_setsigmask, 
-                       _posix_spawnattr_setspecialport_np, _posix_spawnattr_setsuidcredport_np, 
-                       _pread, '_pread$NOCANCEL', _proc_clear_cpulimits, _proc_clear_delayidlesleep, 
-                       _proc_clear_dirty, _proc_clear_vmpressure, _proc_denap_assertion_begin_with_msg, 
-                       _proc_denap_assertion_complete, _proc_disable_apptype, _proc_disable_cpumon, 
-                       _proc_disable_wakemon, _proc_donate_importance_boost, _proc_enable_apptype, 
-                       _proc_get_cpumon_params, _proc_get_dirty, _proc_get_wakemon_params, 
-                       _proc_importance_assertion_begin_with_msg, _proc_importance_assertion_complete, 
-                       _proc_kmsgbuf, _proc_libversion, _proc_list_dynkqueueids, 
-                       _proc_list_uptrs, _proc_listallpids, _proc_listchildpids, 
-                       _proc_listcoalitions, _proc_listpgrppids, _proc_listpids, 
-                       _proc_listpidspath, _proc_name, _proc_pid_rusage, _proc_piddynkqueueinfo, 
-                       _proc_pidfdinfo, _proc_pidfileportinfo, _proc_pidinfo, _proc_pidoriginatorinfo, 
-                       _proc_pidpath, _proc_regionfilename, _proc_reset_footprint_interval, 
-                       _proc_resume_cpumon, _proc_rlimit_control, _proc_set_cpumon_defaults, 
-                       _proc_set_cpumon_params, _proc_set_cpumon_params_fatal, _proc_set_delayidlesleep, 
-                       _proc_set_dirty, _proc_set_owner_vmpressure, _proc_set_wakemon_defaults, 
-                       _proc_set_wakemon_params, _proc_setcpu_percentage, _proc_setpcontrol, 
-                       _proc_setthread_cpupercent, _proc_suppress, _proc_terminate, 
-                       _proc_trace_log, _proc_track_dirty, _proc_udata_info, _proc_uuid_policy, 
-                       _processor_assign, _processor_control, _processor_exit, _processor_get_assignment, 
-                       _processor_info, _processor_set_create, _processor_set_default, 
-                       _processor_set_destroy, _processor_set_info, _processor_set_max_priority, 
-                       _processor_set_policy_control, _processor_set_policy_disable, 
-                       _processor_set_policy_enable, _processor_set_stack_usage, 
-                       _processor_set_statistics, _processor_set_tasks, _processor_set_threads, 
-                       _processor_start, _pselect, '_pselect$1050', '_pselect$DARWIN_EXTSN', 
-                       '_pselect$DARWIN_EXTSN$NOCANCEL', '_pselect$NOCANCEL', _pthread_getugid_np, 
-                       _pthread_setugid_np, _ptrace, _pwrite, '_pwrite$NOCANCEL', 
-                       _quota, _quotactl, _read, '_read$NOCANCEL', _readlink, _readlinkat, 
-                       _readv, '_readv$NOCANCEL', _reboot, _reboot_np, _recvfrom, 
-                       '_recvfrom$NOCANCEL', _recvmsg, '_recvmsg$NOCANCEL', _recvmsg_x, 
-                       _removexattr, _rename, _rename_ext, _renameat, _renameatx_np, 
-                       _renamex_np, _revoke, _rmdir, _searchfs, _select, '_select$1050', 
-                       '_select$DARWIN_EXTSN', '_select$DARWIN_EXTSN$NOCANCEL', '_select$NOCANCEL', 
-                       _sem_close, _sem_destroy, _sem_getvalue, _sem_init, _sem_open, 
-                       _sem_post, _sem_trywait, _sem_unlink, _sem_wait, '_sem_wait$NOCANCEL', 
-                       _semaphore_create, _semaphore_destroy, _semaphore_signal, 
-                       _semaphore_signal_all, _semaphore_signal_all_trap, _semaphore_signal_thread, 
-                       _semaphore_signal_thread_trap, _semaphore_signal_trap, _semaphore_timedwait, 
-                       _semaphore_timedwait_signal, _semaphore_timedwait_signal_trap, 
-                       _semaphore_timedwait_trap, _semaphore_wait, _semaphore_wait_signal, 
-                       _semaphore_wait_signal_trap, _semaphore_wait_trap, _semctl, 
-                       _semget, _semop, _semsys, _sendfile, _sendmsg, '_sendmsg$NOCANCEL', 
-                       _sendmsg_x, _sendto, '_sendto$NOCANCEL', _setattrlist, _setattrlistat, 
-                       _setaudit, _setaudit_addr, _setauid, _setegid, _seteuid, _setgid, 
-                       _setgroups, _setiopolicy_np, _setitimer, _setpgid, _setpriority, 
-                       _setprivexec, _setquota, _setregid, _setreuid, _setrlimit, 
-                       _setsgroups_np, _setsid, _setsockopt, _setuid, _setwgroups_np, 
-                       _setxattr, _sfi_get_class_offtime, _sfi_process_get_flags, 
-                       _sfi_process_set_flags, _sfi_set_class_offtime, _shm_open, 
-                       _shm_unlink, _shmat, _shmctl, _shmdt, _shmget, _shmsys, _shutdown, 
-                       _sigpending, _sigprocmask, _sigsuspend, '_sigsuspend$NOCANCEL', 
-                       _socket, _socket_delegate, _socketpair, _stackshot_capture_with_config, 
-                       _stackshot_config_create, _stackshot_config_dealloc, _stackshot_config_dealloc_buffer, 
-                       _stackshot_config_get_stackshot_buffer, _stackshot_config_get_stackshot_size, 
-                       _stackshot_config_set_delta_timestamp, _stackshot_config_set_flags, 
-                       _stackshot_config_set_pid, _stackshot_config_set_size_hint, 
-                       _stat, '_stat$INODE64', _stat64, _statfs, '_statfs$INODE64', 
-                       _statfs64, _swapon, _swtch, _swtch_pri, _symlink, _symlinkat, 
-                       _sync, _syscall, _syscall_thread_switch, _system_get_sfi_window, 
-                       _system_override, _system_set_sfi_window, _task_assign, _task_assign_default, 
-                       _task_create, _task_create_suid_cred, _task_for_pid, _task_generate_corpse, 
-                       _task_get_assignment, _task_get_dyld_image_infos, _task_get_emulation_vector, 
-                       _task_get_exc_guard_behavior, _task_get_exception_ports, _task_get_mach_voucher, 
-                       _task_get_special_port, _task_get_state, _task_info, _task_inspect, 
-                       _task_map_corpse_info, _task_map_corpse_info_64, _task_name_for_pid, 
-                       _task_policy, _task_policy_get, _task_policy_set, _task_purgable_info, 
-                       _task_register_dyld_get_process_state, _task_register_dyld_image_infos, 
-                       _task_register_dyld_set_dyld_state, _task_register_dyld_shared_cache_image_info, 
-                       _task_restartable_ranges_register, _task_restartable_ranges_synchronize, 
-                       _task_resume, _task_resume2, _task_sample, _task_self_, _task_self_trap, 
-                       _task_set_emulation, _task_set_emulation_vector, _task_set_exc_guard_behavior, 
-                       _task_set_exception_ports, _task_set_info, _task_set_mach_voucher, 
-                       _task_set_phys_footprint_limit, _task_set_policy, _task_set_port_space, 
-                       _task_set_ras_pc, _task_set_special_port, _task_set_state, 
-                       _task_suspend, _task_suspend2, _task_swap_exception_ports, 
-                       _task_swap_mach_voucher, _task_terminate, _task_threads, _task_unregister_dyld_image_infos, 
-                       _task_zone_info, _terminate_with_payload, _terminate_with_reason, 
-                       _thread_abort, _thread_abort_safely, _thread_assign, _thread_assign_default, 
-                       _thread_create, _thread_create_running, _thread_depress_abort, 
-                       _thread_destruct_special_reply_port, _thread_get_assignment, 
-                       _thread_get_exception_ports, _thread_get_mach_voucher, _thread_get_register_pointer_values, 
-                       _thread_get_special_port, _thread_get_special_reply_port, 
-                       _thread_get_state, _thread_info, _thread_policy, _thread_policy_get, 
-                       _thread_policy_set, _thread_resume, _thread_sample, _thread_self_trap, 
-                       _thread_selfcounts, _thread_set_exception_ports, _thread_set_mach_voucher, 
-                       _thread_set_policy, _thread_set_special_port, _thread_set_state, 
-                       _thread_suspend, _thread_swap_exception_ports, _thread_swap_mach_voucher, 
-                       _thread_switch, _thread_terminate, _thread_wire, _truncate, 
-                       _umask, _undelete, _unlink, _unlinkat, _unmount, _usrctl, 
-                       _utimensat, _utimes, _vfork, _vfs_purge, _vm_allocate, _vm_allocate_cpm, 
-                       _vm_behavior_set, _vm_copy, _vm_deallocate, _vm_inherit, _vm_kernel_page_mask, 
-                       _vm_kernel_page_shift, _vm_kernel_page_size, _vm_machine_attribute, 
-                       _vm_map, _vm_map_page_query, _vm_msync, _vm_page_mask, _vm_page_shift, 
-                       _vm_page_size, _vm_pressure_monitor, _vm_protect, _vm_purgable_control, 
-                       _vm_read, _vm_read_list, _vm_read_overwrite, _vm_region_64, 
-                       _vm_region_recurse_64, _vm_remap, _vm_wire, _vm_write, _voucher_mach_msg_adopt, 
-                       _voucher_mach_msg_clear, _voucher_mach_msg_revert, _voucher_mach_msg_set, 
-                       _vprintf_stderr_func, _wait4, _waitevent, _waitid, '_waitid$NOCANCEL', 
-                       _watchevent, _work_interval_copy_port, _work_interval_create, 
-                       _work_interval_destroy, _work_interval_instance_alloc, _work_interval_instance_clear, 
-                       _work_interval_instance_finish, _work_interval_instance_free, 
-                       _work_interval_instance_get_complexity, _work_interval_instance_get_deadline, 
-                       _work_interval_instance_get_finish, _work_interval_instance_get_id, 
-                       _work_interval_instance_get_start, _work_interval_instance_set_complexity, 
-                       _work_interval_instance_set_deadline, _work_interval_instance_set_finish, 
-                       _work_interval_instance_set_start, _work_interval_instance_start, 
-                       _work_interval_instance_update, _work_interval_join, _work_interval_join_port, 
-                       _work_interval_leave, _work_interval_notify, _work_interval_notify_simple, 
-                       _write, '_write$NOCANCEL', _writev, '_writev$NOCANCEL' ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst, x86_64h-macos, x86_64h-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           D1CF3A92-2424-3420-B375-DEED7AA68C53
-  - target:          x86_64-maccatalyst
-    value:           D1CF3A92-2424-3420-B375-DEED7AA68C53
-  - target:          x86_64h-macos
-    value:           00F331F1-0D09-39B3-8736-1FE90E64E903
-  - target:          x86_64h-maccatalyst
-    value:           00F331F1-0D09-39B3-8736-1FE90E64E903
-install-name:    '/usr/lib/system/libsystem_m.dylib'
-current-version: 3178
-exports:
-  - targets:         [ x86_64-macos, x86_64h-macos, x86_64-maccatalyst, x86_64h-maccatalyst ]
-    symbols:         [ __FE_DFL_DISABLE_SSE_DENORMS_ENV, __FE_DFL_ENV, ___Libm_version, 
-                       ___cos_d2, ___cos_d4, ___cos_f4, ___cos_f8, ___cospi, ___cospif, 
-                       ___exp10, ___exp10f, ___fegetfltrounds, ___fpclassify, ___fpclassifyd, 
-                       ___fpclassifyf, ___fpclassifyl, ___inf, ___inff, ___infl, 
-                       ___inline_isfinited, ___inline_isfinitef, ___inline_isfinitel, 
-                       ___inline_isinfd, ___inline_isinff, ___inline_isinfl, ___inline_isnand, 
-                       ___inline_isnanf, ___inline_isnanl, ___inline_isnormald, ___inline_isnormalf, 
-                       ___inline_isnormall, ___inline_signbitd, ___inline_signbitf, 
-                       ___inline_signbitl, ___invert_d2, ___invert_d3, ___invert_d4, 
-                       ___invert_f2, ___invert_f3, ___invert_f4, ___isfinite, ___isfinited, 
-                       ___isfinitef, ___isfinitel, ___isinf, ___isinfd, ___isinff, 
-                       ___isinfl, ___isnan, ___isnand, ___isnanf, ___isnanl, ___isnormal, 
-                       ___isnormald, ___isnormalf, ___isnormall, ___math_errhandling, 
-                       ___nan, ___signbit, ___signbitd, ___signbitf, ___signbitl, 
-                       ___sin_d2, ___sin_d4, ___sin_f4, ___sin_f8, ___sincos, ___sincos_stret, 
-                       ___sincosf, ___sincosf_stret, ___sincospi, ___sincospi_stret, 
-                       ___sincospif, ___sincospif_stret, ___sinpi, ___sinpif, ___tanpi, 
-                       ___tanpif, __simd_acos_d2, __simd_acos_d4, __simd_acos_d8, 
-                       __simd_acos_f16, __simd_acos_f4, __simd_acos_f8, __simd_acosh_d2, 
-                       __simd_acosh_d4, __simd_acosh_d8, __simd_acosh_f16, __simd_acosh_f4, 
-                       __simd_acosh_f8, __simd_asin_d2, __simd_asin_d4, __simd_asin_d8, 
-                       __simd_asin_f16, __simd_asin_f4, __simd_asin_f8, __simd_asinh_d2, 
-                       __simd_asinh_d4, __simd_asinh_d8, __simd_asinh_f16, __simd_asinh_f4, 
-                       __simd_asinh_f8, __simd_atan2_d2, __simd_atan2_d4, __simd_atan2_d8, 
-                       __simd_atan2_f16, __simd_atan2_f4, __simd_atan2_f8, __simd_atan_d2, 
-                       __simd_atan_d4, __simd_atan_d8, __simd_atan_f16, __simd_atan_f4, 
-                       __simd_atan_f8, __simd_atanh_d2, __simd_atanh_d4, __simd_atanh_d8, 
-                       __simd_atanh_f16, __simd_atanh_f4, __simd_atanh_f8, __simd_cbrt_d2, 
-                       __simd_cbrt_d4, __simd_cbrt_d8, __simd_cbrt_f16, __simd_cbrt_f4, 
-                       __simd_cbrt_f8, __simd_cos_d2, __simd_cos_d4, __simd_cos_d8, 
-                       __simd_cos_f16, __simd_cos_f4, __simd_cos_f8, __simd_cosh_d2, 
-                       __simd_cosh_d4, __simd_cosh_d8, __simd_cosh_f16, __simd_cosh_f4, 
-                       __simd_cosh_f8, __simd_cospi_d2, __simd_cospi_d4, __simd_cospi_d8, 
-                       __simd_cospi_f16, __simd_cospi_f4, __simd_cospi_f8, __simd_erf_d2, 
-                       __simd_erf_d4, __simd_erf_d8, __simd_erf_f16, __simd_erf_f4, 
-                       __simd_erf_f8, __simd_erfc_d2, __simd_erfc_d4, __simd_erfc_d8, 
-                       __simd_erfc_f16, __simd_erfc_f4, __simd_erfc_f8, __simd_exp10_d2, 
-                       __simd_exp10_d4, __simd_exp10_d8, __simd_exp10_f16, __simd_exp10_f4, 
-                       __simd_exp10_f8, __simd_exp2_d2, __simd_exp2_d4, __simd_exp2_d8, 
-                       __simd_exp2_f16, __simd_exp2_f4, __simd_exp2_f8, __simd_exp_d2, 
-                       __simd_exp_d4, __simd_exp_d8, __simd_exp_f16, __simd_exp_f4, 
-                       __simd_exp_f8, __simd_expm1_d2, __simd_expm1_d4, __simd_expm1_d8, 
-                       __simd_expm1_f16, __simd_expm1_f4, __simd_expm1_f8, __simd_fma_d2, 
-                       __simd_fma_f4, __simd_fmod_d2, __simd_fmod_d4, __simd_fmod_d8, 
-                       __simd_fmod_f16, __simd_fmod_f4, __simd_fmod_f8, __simd_hypot_d2, 
-                       __simd_hypot_d4, __simd_hypot_d8, __simd_hypot_f16, __simd_hypot_f4, 
-                       __simd_hypot_f8, __simd_incircle_pd2, __simd_incircle_pf2, 
-                       __simd_insphere_pd3, __simd_insphere_pf3, __simd_log10_d2, 
-                       __simd_log10_d4, __simd_log10_d8, __simd_log10_f16, __simd_log10_f4, 
-                       __simd_log10_f8, __simd_log1p_d2, __simd_log1p_d4, __simd_log1p_d8, 
-                       __simd_log1p_f16, __simd_log1p_f4, __simd_log1p_f8, __simd_log2_d2, 
-                       __simd_log2_d4, __simd_log2_d8, __simd_log2_f16, __simd_log2_f4, 
-                       __simd_log2_f8, __simd_log_d2, __simd_log_d4, __simd_log_d8, 
-                       __simd_log_f16, __simd_log_f4, __simd_log_f8, __simd_nextafter_d2, 
-                       __simd_nextafter_d4, __simd_nextafter_d8, __simd_nextafter_f16, 
-                       __simd_nextafter_f4, __simd_nextafter_f8, __simd_orient_pd2, 
-                       __simd_orient_pd3, __simd_orient_pf2, __simd_orient_pf3, __simd_orient_vd2, 
-                       __simd_orient_vd3, __simd_orient_vf2, __simd_orient_vf3, __simd_pow_d2, 
-                       __simd_pow_d4, __simd_pow_d8, __simd_pow_f16, __simd_pow_f4, 
-                       __simd_pow_f8, __simd_remainder_d2, __simd_remainder_d4, __simd_remainder_d8, 
-                       __simd_remainder_f16, __simd_remainder_f4, __simd_remainder_f8, 
-                       __simd_round_d2, __simd_round_d4, __simd_round_d8, __simd_round_f16, 
-                       __simd_round_f4, __simd_round_f8, __simd_sin_d2, __simd_sin_d4, 
-                       __simd_sin_d8, __simd_sin_f16, __simd_sin_f4, __simd_sin_f8, 
-                       __simd_sinh_d2, __simd_sinh_d4, __simd_sinh_d8, __simd_sinh_f16, 
-                       __simd_sinh_f4, __simd_sinh_f8, __simd_sinpi_d2, __simd_sinpi_d4, 
-                       __simd_sinpi_d8, __simd_sinpi_f16, __simd_sinpi_f4, __simd_sinpi_f8, 
-                       __simd_tan_d2, __simd_tan_d4, __simd_tan_d8, __simd_tan_f16, 
-                       __simd_tan_f4, __simd_tan_f8, __simd_tanh_d2, __simd_tanh_d4, 
-                       __simd_tanh_d8, __simd_tanh_f16, __simd_tanh_f4, __simd_tanh_f8, 
-                       __simd_tanpi_d2, __simd_tanpi_d4, __simd_tanpi_d8, __simd_tanpi_f16, 
-                       __simd_tanpi_f4, __simd_tanpi_f8, __simd_tgamma_d2, __simd_tgamma_d4, 
-                       __simd_tgamma_d8, __simd_tgamma_f16, __simd_tgamma_f4, __simd_tgamma_f8, 
-                       _acos, '_acos$fenv_access_off', _acosf, '_acosf$fenv_access_off', 
-                       _acosh, '_acosh$fenv_access_off', _acoshf, '_acoshf$fenv_access_off', 
-                       _acoshl, '_acoshl$fenv_access_off', _acosl, '_acosl$fenv_access_off', 
-                       _asin, '_asin$fenv_access_off', _asinf, '_asinf$fenv_access_off', 
-                       _asinh, '_asinh$fenv_access_off', _asinhf, '_asinhf$fenv_access_off', 
-                       _asinhl, '_asinhl$fenv_access_off', _asinl, '_asinl$fenv_access_off', 
-                       _atan, '_atan$fenv_access_off', _atan2, '_atan2$fenv_access_off', 
-                       _atan2f, '_atan2f$fenv_access_off', _atan2l, '_atan2l$fenv_access_off', 
-                       _atanf, '_atanf$fenv_access_off', _atanh, '_atanh$fenv_access_off', 
-                       _atanhf, '_atanhf$fenv_access_off', _atanhl, '_atanhl$fenv_access_off', 
-                       _atanl, '_atanl$fenv_access_off', _cabs, '_cabs$fenv_access_off', 
-                       _cabsf, '_cabsf$fenv_access_off', _cabsl, '_cabsl$fenv_access_off', 
-                       _cacos, '_cacos$fenv_access_off', _cacosf, '_cacosf$fenv_access_off', 
-                       _cacosh, '_cacosh$fenv_access_off', _cacoshf, '_cacoshf$fenv_access_off', 
-                       _cacoshl, '_cacoshl$fenv_access_off', _cacosl, '_cacosl$fenv_access_off', 
-                       _carg, '_carg$fenv_access_off', _cargf, '_cargf$fenv_access_off', 
-                       _cargl, '_cargl$fenv_access_off', _casin, '_casin$fenv_access_off', 
-                       _casinf, '_casinf$fenv_access_off', _casinh, '_casinh$fenv_access_off', 
-                       _casinhf, '_casinhf$fenv_access_off', _casinhl, '_casinhl$fenv_access_off', 
-                       _casinl, '_casinl$fenv_access_off', _catan, '_catan$fenv_access_off', 
-                       _catanf, '_catanf$fenv_access_off', _catanh, '_catanh$fenv_access_off', 
-                       _catanhf, '_catanhf$fenv_access_off', _catanhl, '_catanhl$fenv_access_off', 
-                       _catanl, '_catanl$fenv_access_off', _cbrt, '_cbrt$fenv_access_off', 
-                       _cbrtf, '_cbrtf$fenv_access_off', _cbrtl, '_cbrtl$fenv_access_off', 
-                       _ccos, '_ccos$fenv_access_off', _ccosf, '_ccosf$fenv_access_off', 
-                       _ccosh, '_ccosh$fenv_access_off', _ccoshf, '_ccoshf$fenv_access_off', 
-                       _ccoshl, '_ccoshl$fenv_access_off', _ccosl, '_ccosl$fenv_access_off', 
-                       _ceil, '_ceil$fenv_access_off', _ceilf, '_ceilf$fenv_access_off', 
-                       _ceill, '_ceill$fenv_access_off', _cexp, '_cexp$fenv_access_off', 
-                       _cexpf, '_cexpf$fenv_access_off', _cexpl, '_cexpl$fenv_access_off', 
-                       _cimag, '_cimag$fenv_access_off', _cimagf, '_cimagf$fenv_access_off', 
-                       _cimagl, '_cimagl$fenv_access_off', _clog, '_clog$fenv_access_off', 
-                       _clogf, '_clogf$fenv_access_off', _clogl, '_clogl$fenv_access_off', 
-                       _conj, '_conj$fenv_access_off', _conjf, '_conjf$fenv_access_off', 
-                       _conjl, '_conjl$fenv_access_off', _copysign, '_copysign$fenv_access_off', 
-                       _copysignf, '_copysignf$fenv_access_off', _copysignl, '_copysignl$fenv_access_off', 
-                       _cos, '_cos$fenv_access_off', _cosf, '_cosf$fenv_access_off', 
-                       _cosh, '_cosh$fenv_access_off', _coshf, '_coshf$fenv_access_off', 
-                       _coshl, '_coshl$fenv_access_off', _cosl, '_cosl$fenv_access_off', 
-                       _cpow, '_cpow$fenv_access_off', _cpowf, '_cpowf$fenv_access_off', 
-                       _cpowl, '_cpowl$fenv_access_off', _cproj, '_cproj$fenv_access_off', 
-                       _cprojf, '_cprojf$fenv_access_off', _cprojl, '_cprojl$fenv_access_off', 
-                       _creal, '_creal$fenv_access_off', _crealf, '_crealf$fenv_access_off', 
-                       _creall, '_creall$fenv_access_off', _csin, '_csin$fenv_access_off', 
-                       _csinf, '_csinf$fenv_access_off', _csinh, '_csinh$fenv_access_off', 
-                       _csinhf, '_csinhf$fenv_access_off', _csinhl, '_csinhl$fenv_access_off', 
-                       _csinl, '_csinl$fenv_access_off', _csqrt, '_csqrt$fenv_access_off', 
-                       _csqrtf, '_csqrtf$fenv_access_off', _csqrtl, '_csqrtl$fenv_access_off', 
-                       _ctan, '_ctan$fenv_access_off', _ctanf, '_ctanf$fenv_access_off', 
-                       _ctanh, '_ctanh$fenv_access_off', _ctanhf, '_ctanhf$fenv_access_off', 
-                       _ctanhl, '_ctanhl$fenv_access_off', _ctanl, '_ctanl$fenv_access_off', 
-                       _drem, _erf, '_erf$fenv_access_off', _erfc, '_erfc$fenv_access_off', 
-                       _erfcf, '_erfcf$fenv_access_off', _erfcl, '_erfcl$fenv_access_off', 
-                       _erff, '_erff$fenv_access_off', _erfl, '_erfl$fenv_access_off', 
-                       _exp, '_exp$fenv_access_off', _exp2, '_exp2$fenv_access_off', 
-                       _exp2f, '_exp2f$fenv_access_off', _exp2l, '_exp2l$fenv_access_off', 
-                       _expf, '_expf$fenv_access_off', _expl, '_expl$fenv_access_off', 
-                       _expm1, '_expm1$fenv_access_off', _expm1f, '_expm1f$fenv_access_off', 
-                       _expm1l, '_expm1l$fenv_access_off', _fabs, '_fabs$fenv_access_off', 
-                       _fabsf, '_fabsf$fenv_access_off', _fabsl, '_fabsl$fenv_access_off', 
-                       _fdim, '_fdim$fenv_access_off', _fdimf, '_fdimf$fenv_access_off', 
-                       _fdiml, '_fdiml$fenv_access_off', _feclearexcept, _fegetenv, 
-                       _fegetexcept, _fegetexceptflag, _fegetround, _feholdexcept, 
-                       _feraiseexcept, _fesetenv, _fesetexcept, _fesetexceptflag, 
-                       _fesetround, _fetestexcept, _feupdateenv, _finite, _floor, 
-                       '_floor$fenv_access_off', _floorf, '_floorf$fenv_access_off', 
-                       _floorl, '_floorl$fenv_access_off', _fma, '_fma$fenv_access_off', 
-                       _fmaf, '_fmaf$fenv_access_off', _fmal, '_fmal$fenv_access_off', 
-                       _fmax, '_fmax$fenv_access_off', _fmaxf, '_fmaxf$fenv_access_off', 
-                       _fmaxl, '_fmaxl$fenv_access_off', _fmin, '_fmin$fenv_access_off', 
-                       _fminf, '_fminf$fenv_access_off', _fminl, '_fminl$fenv_access_off', 
-                       _fmod, '_fmod$fenv_access_off', _fmodf, '_fmodf$fenv_access_off', 
-                       _fmodl, '_fmodl$fenv_access_off', _frexp, '_frexp$fenv_access_off', 
-                       _frexpf, '_frexpf$fenv_access_off', _frexpl, '_frexpl$fenv_access_off', 
-                       _gamma, '_gamma$fenv_access_off', _hypot, '_hypot$fenv_access_off', 
-                       _hypotf, '_hypotf$fenv_access_off', _hypotl, '_hypotl$fenv_access_off', 
-                       _ilogb, '_ilogb$fenv_access_off', _ilogbf, '_ilogbf$fenv_access_off', 
-                       _ilogbl, '_ilogbl$fenv_access_off', _isinf, _isnan, _j0, _j1, 
-                       _jn, _ldexp, '_ldexp$fenv_access_off', _ldexpf, '_ldexpf$fenv_access_off', 
-                       _ldexpl, '_ldexpl$fenv_access_off', _lgamma, '_lgamma$fenv_access_off', 
-                       _lgamma_r, '_lgamma_r$fenv_access_off', _lgammaf, '_lgammaf$fenv_access_off', 
-                       _lgammaf_r, '_lgammaf_r$fenv_access_off', _lgammal, '_lgammal$fenv_access_off', 
-                       _lgammal_r, '_lgammal_r$fenv_access_off', _llrint, '_llrint$fenv_access_off', 
-                       _llrintf, '_llrintf$fenv_access_off', _llrintl, '_llrintl$fenv_access_off', 
-                       _llround, '_llround$fenv_access_off', _llroundf, '_llroundf$fenv_access_off', 
-                       _llroundl, '_llroundl$fenv_access_off', _log, '_log$fenv_access_off', 
-                       _log10, '_log10$fenv_access_off', _log10f, '_log10f$fenv_access_off', 
-                       _log10l, '_log10l$fenv_access_off', _log1p, '_log1p$fenv_access_off', 
-                       _log1pf, '_log1pf$fenv_access_off', _log1pl, '_log1pl$fenv_access_off', 
-                       _log2, '_log2$fenv_access_off', _log2f, '_log2f$fenv_access_off', 
-                       _log2l, '_log2l$fenv_access_off', _logb, '_logb$fenv_access_off', 
-                       _logbf, '_logbf$fenv_access_off', _logbl, '_logbl$fenv_access_off', 
-                       _logf, '_logf$fenv_access_off', _logl, '_logl$fenv_access_off', 
-                       _lrint, '_lrint$fenv_access_off', _lrintf, '_lrintf$fenv_access_off', 
-                       _lrintl, '_lrintl$fenv_access_off', _lround, '_lround$fenv_access_off', 
-                       _lroundf, '_lroundf$fenv_access_off', _lroundl, '_lroundl$fenv_access_off', 
-                       _matherr, _matrix_identity_double2x2, _matrix_identity_double3x3, 
-                       _matrix_identity_double4x4, _matrix_identity_float2x2, _matrix_identity_float3x3, 
-                       _matrix_identity_float4x4, _modf, '_modf$fenv_access_off', 
-                       _modff, '_modff$fenv_access_off', _modfl, '_modfl$fenv_access_off', 
-                       _nan, _nanf, _nanl, _nearbyint, '_nearbyint$fenv_access_off', 
-                       _nearbyintf, '_nearbyintf$fenv_access_off', _nearbyintl, '_nearbyintl$fenv_access_off', 
-                       _nextafter, '_nextafter$fenv_access_off', _nextafterd, _nextafterf, 
-                       '_nextafterf$fenv_access_off', _nextafterl, '_nextafterl$fenv_access_off', 
-                       _nexttoward, '_nexttoward$fenv_access_off', _nexttowardf, 
-                       '_nexttowardf$fenv_access_off', _nexttowardl, '_nexttowardl$fenv_access_off', 
-                       _pow, '_pow$fenv_access_off', _powf, '_powf$fenv_access_off', 
-                       _powl, '_powl$fenv_access_off', _remainder, '_remainder$fenv_access_off', 
-                       _remainderf, '_remainderf$fenv_access_off', _remainderl, '_remainderl$fenv_access_off', 
-                       _remquo, '_remquo$fenv_access_off', _remquof, '_remquof$fenv_access_off', 
-                       _remquol, '_remquol$fenv_access_off', _rint, '_rint$fenv_access_off', 
-                       _rintf, '_rintf$fenv_access_off', _rintl, '_rintl$fenv_access_off', 
-                       _rinttol, _round, '_round$fenv_access_off', _roundf, '_roundf$fenv_access_off', 
-                       _roundl, '_roundl$fenv_access_off', _roundtol, _scalb, _scalbln, 
-                       '_scalbln$fenv_access_off', _scalblnf, '_scalblnf$fenv_access_off', 
-                       _scalblnl, '_scalblnl$fenv_access_off', _scalbn, '_scalbn$fenv_access_off', 
-                       _scalbnf, '_scalbnf$fenv_access_off', _scalbnl, '_scalbnl$fenv_access_off', 
-                       _signgam, _significand, _sin, '_sin$fenv_access_off', _sinf, 
-                       '_sinf$fenv_access_off', _sinh, '_sinh$fenv_access_off', _sinhf, 
-                       '_sinhf$fenv_access_off', _sinhl, '_sinhl$fenv_access_off', 
-                       _sinl, '_sinl$fenv_access_off', _sqrt, '_sqrt$fenv_access_off', 
-                       _sqrtf, '_sqrtf$fenv_access_off', _sqrtl, '_sqrtl$fenv_access_off', 
-                       _tan, '_tan$fenv_access_off', _tanf, '_tanf$fenv_access_off', 
-                       _tanh, '_tanh$fenv_access_off', _tanhf, '_tanhf$fenv_access_off', 
-                       _tanhl, '_tanhl$fenv_access_off', _tanl, '_tanl$fenv_access_off', 
-                       _tgamma, '_tgamma$fenv_access_off', _tgammaf, '_tgammaf$fenv_access_off', 
-                       _tgammal, '_tgammal$fenv_access_off', _trunc, '_trunc$fenv_access_off', 
-                       _truncf, '_truncf$fenv_access_off', _truncl, '_truncl$fenv_access_off', 
-                       _y0, _y1, _yn ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           8549294E-4C53-36EB-99F3-584A7393D8D5
-  - target:          x86_64-maccatalyst
-    value:           8549294E-4C53-36EB-99F3-584A7393D8D5
-install-name:    '/usr/lib/system/libsystem_malloc.dylib'
-current-version: 283.100.6
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ ___mach_stack_logging_copy_uniquing_table, ___mach_stack_logging_enumerate_records, 
-                       ___mach_stack_logging_frames_for_uniqued_stack, ___mach_stack_logging_get_frames, 
-                       ___mach_stack_logging_get_frames_for_stackid, ___mach_stack_logging_set_file_path, 
-                       ___mach_stack_logging_shared_memory_address, ___mach_stack_logging_stackid_for_vm_region, 
-                       ___mach_stack_logging_start_reading, ___mach_stack_logging_stop_reading, 
-                       ___mach_stack_logging_uniquing_table_copy_from_serialized, 
-                       ___mach_stack_logging_uniquing_table_read_stack, ___mach_stack_logging_uniquing_table_release, 
-                       ___mach_stack_logging_uniquing_table_retain, ___mach_stack_logging_uniquing_table_serialize, 
-                       ___mach_stack_logging_uniquing_table_sizeof, ___malloc_init, 
-                       ___stack_logging_early_finished, __malloc_fork_child, __malloc_fork_parent, 
-                       __malloc_fork_prepare, __malloc_no_asl_log, __os_cpu_number_override, 
-                       _aligned_alloc, _calloc, _free, _mag_set_thread_index, _malloc, 
-                       _malloc_check_counter, _malloc_check_each, _malloc_check_start, 
-                       _malloc_claimed_address, _malloc_create_legacy_default_zone, 
-                       _malloc_create_zone, _malloc_debug, _malloc_default_purgeable_zone, 
-                       _malloc_default_zone, _malloc_destroy_zone, _malloc_engaged_nano, 
-                       _malloc_enter_process_memory_limit_warn_mode, _malloc_error, 
-                       _malloc_freezedry, _malloc_get_all_zones, _malloc_get_zone_name, 
-                       _malloc_good_size, _malloc_jumpstart, _malloc_logger, _malloc_make_nonpurgeable, 
-                       _malloc_make_purgeable, _malloc_memory_event_handler, _malloc_num_zones, 
-                       _malloc_num_zones_allocated, _malloc_printf, _malloc_register_stack_logger, 
-                       _malloc_set_zone_name, _malloc_singlethreaded, _malloc_size, 
-                       _malloc_zone_batch_free, _malloc_zone_batch_malloc, _malloc_zone_calloc, 
-                       _malloc_zone_check, _malloc_zone_claimed_address, _malloc_zone_disable_discharge_checking, 
-                       _malloc_zone_discharge, _malloc_zone_enable_discharge_checking, 
-                       _malloc_zone_enumerate_discharged_pointers, _malloc_zone_free, 
-                       _malloc_zone_from_ptr, _malloc_zone_log, _malloc_zone_malloc, 
-                       _malloc_zone_memalign, _malloc_zone_pressure_relief, _malloc_zone_print, 
-                       _malloc_zone_print_ptr_info, _malloc_zone_realloc, _malloc_zone_register, 
-                       _malloc_zone_statistics, _malloc_zone_unregister, _malloc_zone_valloc, 
-                       _malloc_zones, _mstats, _posix_memalign, _realloc, '_reallocarray$DARWIN_EXTSN', 
-                       '_reallocarrayf$DARWIN_EXTSN', _scalable_zone_info, _scalable_zone_statistics, 
-                       _set_malloc_singlethreaded, _stack_logging_enable_logging, 
-                       _szone_check_counter, _szone_check_modulo, _szone_check_start, 
-                       _tiny_print_region_free_list, _turn_off_stack_logging, _turn_on_stack_logging, 
-                       _valloc, _vfree, _zeroify_scalable_zone ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           F06C65C5-2CBE-313C-96E1-A09240F9FE57
-  - target:          x86_64-maccatalyst
-    value:           F06C65C5-2CBE-313C-96E1-A09240F9FE57
-install-name:    '/usr/lib/system/libsystem_networkextension.dylib'
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _NEHelperCacheAddRedirectedAddress, _NEHelperCacheClearRedirectedAddresses, 
-                       _NEHelperCacheClearUUIDs, _NEHelperCacheCopyAppUUIDMapping, 
-                       _NEHelperCacheCopyAppUUIDMappingExtended, _NEHelperCacheCopyAppUUIDMappingForUIDExtended, 
-                       _NEHelperCacheCopySigningIdentifierMapping, _NEHelperCacheSetDomainDictionaries, 
-                       _NEHelperCacheSetRoutes, _NEHelperCopyAggregatePathRules, 
-                       _NEHelperCopyAppInfo, _NEHelperCopyCurrentNetworkInfo, _NEHelperCopyPerAppDomains, 
-                       _NEHelperCopyPreferredBundleID, _NEHelperCopyResponse, _NEHelperGetIKESocket, 
-                       _NEHelperGetIKESocketWithResult, _NEHelperGetKernelControlSocket, 
-                       _NEHelperGetKernelControlSocketExtended, _NEHelperGetNECPSessionFD, 
-                       _NEHelperGetPFKeySocket, _NEHelperHandleConfigurationsChangedBySC, 
-                       _NEHelperInit, _NEHelperInterfaceRemoveAddress, _NEHelperInterfaceSetAddress, 
-                       _NEHelperInterfaceSetMTU, _NEHelperInterfaceSetOption, _NEHelperSendRequest, 
-                       _NEHelperSettingsSetArray, _NEHelperSettingsSetBool, _NEHelperSettingsSetNumber, 
-                       _NEHelperVPNConfigurationExists, _NEHelperVPNSetEnabled, _g_ne_read_uuid_cache, 
-                       _g_ne_uuid_cache_hit, _ne_copy_cached_bundle_identifier_for_uuid, 
-                       _ne_copy_cached_preferred_bundle_for_bundle_identifier, _ne_copy_cached_uuids_for_bundle_identifier, 
-                       _ne_copy_signature_info_for_pid, _ne_copy_signing_identifier_for_pid, 
-                       _ne_copy_uuid_cache, _ne_force_reset_uuid_cache, _ne_get_configuration_generation, 
-                       _ne_log_large_obj, _ne_log_obj, _ne_print_backtrace, _ne_session_add_necp_drop_dest_from_path, 
-                       _ne_session_address_matches_subnets, _ne_session_agent_get_advisory, 
-                       _ne_session_agent_get_advisory_interface_index, _ne_session_always_on_vpn_configs_present, 
-                       _ne_session_always_on_vpn_configs_present_at_boot, _ne_session_app_vpn_configs_present, 
-                       _ne_session_cancel, _ne_session_content_filter_configs_present, 
-                       _ne_session_copy_app_data_from_flow_divert_socket, _ne_session_copy_app_data_from_flow_divert_token, 
-                       _ne_session_copy_policy_match, _ne_session_copy_security_session_info, 
-                       _ne_session_copy_socket_attributes, _ne_session_create, _ne_session_disable_restrictions, 
-                       _ne_session_dns_proxy_configs_present, _ne_session_establish_ipc, 
-                       _ne_session_fallback_advisory, _ne_session_fallback_default, 
-                       _ne_session_get_config_id_from_network_agent, _ne_session_get_configuration_id, 
-                       _ne_session_get_info, _ne_session_get_info2, _ne_session_get_status, 
-                       _ne_session_info_type_to_string, _ne_session_initialize_necp_drop_all, 
-                       _ne_session_is_safeboot, _ne_session_manager_get_pid, _ne_session_manager_has_active_sessions, 
-                       _ne_session_manager_is_running, _ne_session_on_demand_configs_present, 
-                       _ne_session_path_controller_configs_present, _ne_session_policy_copy_flow_divert_token, 
-                       _ne_session_policy_copy_flow_divert_token_with_key, _ne_session_policy_match_get_filter_unit, 
-                       _ne_session_policy_match_get_flow_divert_unit, _ne_session_policy_match_get_scoped_interface_index, 
-                       _ne_session_policy_match_get_service, _ne_session_policy_match_get_service_action, 
-                       _ne_session_policy_match_get_service_type, _ne_session_policy_match_is_drop, 
-                       _ne_session_policy_match_is_flow_divert, _ne_session_policy_match_service_is_registered, 
-                       _ne_session_release, _ne_session_retain, _ne_session_send_barrier, 
-                       _ne_session_service_get_dns_service_id, _ne_session_service_get_dns_service_id_for_interface, 
-                       _ne_session_service_matches_address, _ne_session_service_matches_address_for_interface, 
-                       _ne_session_set_event_handler, _ne_session_set_socket_attributes, 
-                       _ne_session_should_disable_nexus, _ne_session_start, _ne_session_start_on_behalf_of, 
-                       _ne_session_start_with_options, _ne_session_status_to_string, 
-                       _ne_session_stop, _ne_session_stop_all_with_plugin_type, _ne_session_stop_reason_to_string, 
-                       _ne_session_type_to_string, _ne_session_use_as_system_vpn, 
-                       _ne_session_use_ikev2provider, _nehelper_copy_connection, 
-                       _nehelper_queue, _nelog_is_debug_logging_enabled, _nelog_is_extra_vpn_logging_enabled, 
-                       _nelog_is_info_logging_enabled ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           FA22F928-D91B-3AA5-96BB-3186AC0FB264
-  - target:          x86_64-maccatalyst
-    value:           FA22F928-D91B-3AA5-96BB-3186AC0FB264
-install-name:    '/usr/lib/system/libsystem_notify.dylib'
-current-version: 241.100.2
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ __notify_fork_child, _notify_cancel, _notify_check, _notify_dump_status, 
-                       _notify_get_event, _notify_get_state, _notify_is_valid_token, 
-                       _notify_monitor_file, _notify_peek, _notify_post, _notify_register_check, 
-                       _notify_register_dispatch, _notify_register_file_descriptor, 
-                       _notify_register_mach_port, _notify_register_plain, _notify_register_signal, 
-                       _notify_resume, _notify_resume_pid, _notify_set_options, _notify_set_state, 
-                       _notify_simple_post, _notify_suspend, _notify_suspend_pid ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           009A7C1F-313A-318E-B9F2-30F4C06FEA5C
-  - target:          x86_64-maccatalyst
-    value:           009A7C1F-313A-318E-B9F2-30F4C06FEA5C
-install-name:    '/usr/lib/system/libsystem_platform.dylib'
-current-version: 220.100.1
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _OSAtomicAdd32, _OSAtomicAdd32Barrier, _OSAtomicAdd64, _OSAtomicAdd64Barrier, 
-                       _OSAtomicAnd32, _OSAtomicAnd32Barrier, _OSAtomicAnd32Orig, 
-                       _OSAtomicAnd32OrigBarrier, _OSAtomicCompareAndSwap32, _OSAtomicCompareAndSwap32Barrier, 
-                       _OSAtomicCompareAndSwap64, _OSAtomicCompareAndSwap64Barrier, 
-                       _OSAtomicCompareAndSwapInt, _OSAtomicCompareAndSwapIntBarrier, 
-                       _OSAtomicCompareAndSwapLong, _OSAtomicCompareAndSwapLongBarrier, 
-                       _OSAtomicCompareAndSwapPtr, _OSAtomicCompareAndSwapPtrBarrier, 
-                       _OSAtomicDecrement32, _OSAtomicDecrement32Barrier, _OSAtomicDecrement64, 
-                       _OSAtomicDecrement64Barrier, _OSAtomicDequeue, _OSAtomicEnqueue, 
-                       _OSAtomicFifoDequeue, _OSAtomicFifoEnqueue, _OSAtomicIncrement32, 
-                       _OSAtomicIncrement32Barrier, _OSAtomicIncrement64, _OSAtomicIncrement64Barrier, 
-                       _OSAtomicOr32, _OSAtomicOr32Barrier, _OSAtomicOr32Orig, _OSAtomicOr32OrigBarrier, 
-                       _OSAtomicTestAndClear, _OSAtomicTestAndClearBarrier, _OSAtomicTestAndSet, 
-                       _OSAtomicTestAndSetBarrier, _OSAtomicXor32, _OSAtomicXor32Barrier, 
-                       _OSAtomicXor32Orig, _OSAtomicXor32OrigBarrier, _OSMemoryBarrier, 
-                       _OSSpinLockLock, _OSSpinLockTry, _OSSpinLockUnlock, ___bzero, 
-                       ___libplatform_init, ___os_once_reset, ___platform_sigaction, 
-                       __longjmp, __os_alloc_once, __os_lock_type_eliding, __os_lock_type_handoff, 
-                       __os_lock_type_nospin, __os_lock_type_spin, __os_lock_type_transactional, 
-                       __os_lock_type_unfair, __os_nospin_lock_lock, __os_nospin_lock_trylock, 
-                       __os_nospin_lock_unlock, __os_once, __os_semaphore_create, 
-                       __os_semaphore_dispose, __os_semaphore_signal, __os_semaphore_wait, 
-                       __platform_bzero, __platform_memccpy, __platform_memchr, __platform_memcmp, 
-                       __platform_memmove, __platform_memset, __platform_memset_pattern16, 
-                       __platform_memset_pattern4, __platform_memset_pattern8, __platform_strchr, 
-                       __platform_strcmp, __platform_strcpy, __platform_strlcat, 
-                       __platform_strlcpy, __platform_strlen, __platform_strncmp, 
-                       __platform_strncpy, __platform_strnlen, __platform_strstr, 
-                       __setjmp, __sigtramp, __simple_asl_log, __simple_asl_log_prog, 
-                       __simple_asl_msg_new, __simple_asl_msg_set, __simple_asl_send, 
-                       __simple_dprintf, __simple_esappend, __simple_esprintf, __simple_getenv, 
-                       __simple_put, __simple_putline, __simple_salloc, __simple_sappend, 
-                       __simple_sfree, __simple_sprintf, __simple_sresize, __simple_string, 
-                       __simple_vdprintf, __simple_vesprintf, __simple_vsprintf, 
-                       __spin_lock, __spin_lock_try, __spin_unlock, _ffs, _ffsl, 
-                       _ffsll, _fls, _flsl, _flsll, _getcontext, _longjmp, _longjmperror, 
-                       _makecontext, _os_lock_lock, _os_lock_trylock, _os_lock_unlock, 
-                       _os_unfair_lock_assert_not_owner, _os_unfair_lock_assert_owner, 
-                       _os_unfair_lock_lock, _os_unfair_lock_lock_no_tsd_4libpthread, 
-                       _os_unfair_lock_lock_with_options, _os_unfair_lock_lock_with_options_4Libc, 
-                       _os_unfair_lock_trylock, _os_unfair_lock_unlock, _os_unfair_lock_unlock_4Libc, 
-                       _os_unfair_lock_unlock_no_tsd_4libpthread, _os_unfair_recursive_lock_lock_with_options, 
-                       _os_unfair_recursive_lock_owned, _os_unfair_recursive_lock_trylock, 
-                       _os_unfair_recursive_lock_tryunlock4objc, _os_unfair_recursive_lock_unlock, 
-                       _os_unfair_recursive_lock_unlock_forked_child, _platform_task_attach, 
-                       _platform_task_copy_next_thread, _platform_task_detach, _platform_task_is_64_bit, 
-                       _platform_task_perform, _platform_task_resume_threads, _platform_task_suspend_threads, 
-                       _platform_task_update_threads, _platform_thread_abort_safely, 
-                       _platform_thread_get_pthread, _platform_thread_get_state, 
-                       _platform_thread_get_unique_id, _platform_thread_info, _platform_thread_perform, 
-                       _platform_thread_release, _platform_thread_resume, _platform_thread_set_state, 
-                       _platform_thread_suspend, _setcontext, _setjmp, _siglongjmp, 
-                       _sigsetjmp, _spin_lock, _spin_lock_try, _spin_unlock, _swapcontext, 
-                       _sys_cache_control, _sys_dcache_flush, _sys_icache_invalidate ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           62CB1A98-0B8F-31E7-A02B-A1139927F61D
-  - target:          x86_64-maccatalyst
-    value:           62CB1A98-0B8F-31E7-A02B-A1139927F61D
-install-name:    '/usr/lib/system/libsystem_pthread.dylib'
-current-version: 416.100.3
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ ____chkstk_darwin, ___is_threaded, ___pthread_init, ___pthread_workqueue_setkill, 
-                       ___unix_conforming, __pthread_atfork_child, __pthread_atfork_child_handlers, 
-                       __pthread_atfork_parent, __pthread_atfork_parent_handlers, 
-                       __pthread_atfork_prepare, __pthread_atfork_prepare_handlers, 
-                       __pthread_clear_qos_tsd, __pthread_exit_if_canceled, __pthread_fork_child, 
-                       __pthread_fork_child_postinit, __pthread_fork_parent, __pthread_fork_prepare, 
-                       __pthread_is_threaded, __pthread_joiner_wake, __pthread_mutex_enable_legacy_mode, 
-                       __pthread_override_qos_class_end_direct, __pthread_override_qos_class_start_direct, 
-                       __pthread_qos_class_decode, __pthread_qos_class_encode, __pthread_qos_class_encode_workqueue, 
-                       __pthread_qos_override_end_direct, __pthread_qos_override_start_direct, 
-                       __pthread_self, __pthread_set_properties_self, __pthread_set_self, 
-                       __pthread_setspecific_static, __pthread_start, __pthread_testcancel, 
-                       __pthread_workloop_create, __pthread_workloop_destroy, __pthread_workqueue_addthreads, 
-                       __pthread_workqueue_asynchronous_override_add, __pthread_workqueue_asynchronous_override_reset_all_self, 
-                       __pthread_workqueue_asynchronous_override_reset_self, __pthread_workqueue_init, 
-                       __pthread_workqueue_init_with_kevent, __pthread_workqueue_init_with_workloop, 
-                       __pthread_workqueue_override_reset, __pthread_workqueue_override_start_direct, 
-                       __pthread_workqueue_override_start_direct_check_owner, __pthread_workqueue_set_event_manager_priority, 
-                       __pthread_workqueue_should_narrow, __pthread_workqueue_supported, 
-                       __pthread_wqthread, _cthread_yield, _posix_spawnattr_get_qos_class_np, 
-                       _posix_spawnattr_set_qos_class_np, _pthread_atfork, _pthread_attr_destroy, 
-                       _pthread_attr_get_qos_class_np, _pthread_attr_getdetachstate, 
-                       _pthread_attr_getguardsize, _pthread_attr_getinheritsched, 
-                       _pthread_attr_getschedparam, _pthread_attr_getschedpolicy, 
-                       _pthread_attr_getscope, _pthread_attr_getstack, _pthread_attr_getstackaddr, 
-                       _pthread_attr_getstacksize, _pthread_attr_init, _pthread_attr_set_qos_class_np, 
-                       _pthread_attr_setcpupercent_np, _pthread_attr_setdetachstate, 
-                       _pthread_attr_setguardsize, _pthread_attr_setinheritsched, 
-                       _pthread_attr_setschedparam, _pthread_attr_setschedpolicy, 
-                       _pthread_attr_setscope, _pthread_attr_setstack, _pthread_attr_setstackaddr, 
-                       _pthread_attr_setstacksize, _pthread_cancel, _pthread_chdir_np, 
-                       _pthread_cond_broadcast, _pthread_cond_destroy, _pthread_cond_init, 
-                       _pthread_cond_signal, _pthread_cond_signal_thread_np, _pthread_cond_timedwait, 
-                       '_pthread_cond_timedwait$NOCANCEL', _pthread_cond_timedwait_relative_np, 
-                       _pthread_cond_wait, '_pthread_cond_wait$NOCANCEL', _pthread_condattr_destroy, 
-                       _pthread_condattr_getpshared, _pthread_condattr_init, _pthread_condattr_setpshared, 
-                       _pthread_create, _pthread_create_from_mach_thread, _pthread_create_suspended_np, 
-                       _pthread_current_stack_contains_np, _pthread_dependency_fulfill_np, 
-                       _pthread_dependency_init_np, _pthread_dependency_wait_np, 
-                       _pthread_detach, _pthread_equal, _pthread_exit, _pthread_fchdir_np, 
-                       _pthread_from_mach_thread_np, _pthread_get_qos_class_np, _pthread_get_stackaddr_np, 
-                       _pthread_get_stacksize_np, _pthread_getconcurrency, _pthread_getname_np, 
-                       _pthread_getschedparam, _pthread_getspecific, _pthread_introspection_hook_install, 
-                       _pthread_is_threaded_np, _pthread_join, '_pthread_join$NOCANCEL', 
-                       _pthread_key_create, _pthread_key_delete, _pthread_key_init_np, 
-                       _pthread_kill, _pthread_layout_offsets, _pthread_mach_thread_np, 
-                       _pthread_main_np, _pthread_main_thread_np, _pthread_mutex_destroy, 
-                       _pthread_mutex_getprioceiling, _pthread_mutex_init, _pthread_mutex_lock, 
-                       _pthread_mutex_setprioceiling, _pthread_mutex_trylock, _pthread_mutex_unlock, 
-                       _pthread_mutexattr_destroy, _pthread_mutexattr_getpolicy_np, 
-                       _pthread_mutexattr_getprioceiling, _pthread_mutexattr_getprotocol, 
-                       _pthread_mutexattr_getpshared, _pthread_mutexattr_gettype, 
-                       _pthread_mutexattr_init, _pthread_mutexattr_setpolicy_np, 
-                       _pthread_mutexattr_setprioceiling, _pthread_mutexattr_setprotocol, 
-                       _pthread_mutexattr_setpshared, _pthread_mutexattr_settype, 
-                       _pthread_once, _pthread_override_qos_class_end_np, _pthread_override_qos_class_start_np, 
-                       _pthread_prefer_alternate_amx_self, _pthread_qos_max_parallelism, 
-                       _pthread_rwlock_destroy, _pthread_rwlock_init, _pthread_rwlock_rdlock, 
-                       _pthread_rwlock_tryrdlock, _pthread_rwlock_trywrlock, _pthread_rwlock_unlock, 
-                       _pthread_rwlock_wrlock, _pthread_rwlockattr_destroy, _pthread_rwlockattr_getpshared, 
-                       _pthread_rwlockattr_init, _pthread_rwlockattr_setpshared, 
-                       _pthread_self, _pthread_set_fixedpriority_self, _pthread_set_qos_class_np, 
-                       _pthread_set_qos_class_self_np, _pthread_set_timeshare_self, 
-                       _pthread_setcancelstate, _pthread_setcanceltype, _pthread_setconcurrency, 
-                       _pthread_setname_np, _pthread_setschedparam, _pthread_setspecific, 
-                       _pthread_sigmask, _pthread_stack_frame_decode_np, _pthread_testcancel, 
-                       _pthread_threadid_np, _pthread_time_constraint_max_parallelism, 
-                       _pthread_workqueue_addthreads_np, _pthread_workqueue_setdispatch_np, 
-                       _pthread_workqueue_setdispatchoffset_np, _pthread_workqueue_setup, 
-                       _pthread_yield_np, _qos_class_main, _qos_class_self, _sched_get_priority_max, 
-                       _sched_get_priority_min, _sched_yield, _sigwait, '_sigwait$NOCANCEL', 
-                       _start_wqthread, _thread_chkstk_darwin, _thread_start ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           4ADBB2C0-C8B9-39FF-B9AF-2E00460A0FD6
-  - target:          x86_64-maccatalyst
-    value:           4ADBB2C0-C8B9-39FF-B9AF-2E00460A0FD6
-install-name:    '/usr/lib/system/libsystem_sandbox.dylib'
-current-version: 1217.140.4
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _APP_SANDBOX_IOKIT_CLIENT, _APP_SANDBOX_MACH, _APP_SANDBOX_READ, 
-                       _APP_SANDBOX_READ_WRITE, _IOS_SANDBOX_APPLICATION_GROUP, _IOS_SANDBOX_CONTAINER, 
-                       _SANDBOX_CHECK_ALLOW_APPROVAL, _SANDBOX_CHECK_CANONICAL, _SANDBOX_CHECK_NOFOLLOW, 
-                       _SANDBOX_CHECK_NO_APPROVAL, _SANDBOX_CHECK_NO_REPORT, _SANDBOX_EXTENSION_CANONICAL, 
-                       _SANDBOX_EXTENSION_DEFAULT, _SANDBOX_EXTENSION_MACL_LEARNING, 
-                       _SANDBOX_EXTENSION_MAGIC, _SANDBOX_EXTENSION_NOFOLLOW, _SANDBOX_EXTENSION_NO_REPORT, 
-                       _SANDBOX_EXTENSION_NO_STORAGE_CLASS, _SANDBOX_EXTENSION_PREFIXMATCH, 
-                       _SANDBOX_EXTENSION_UNRESOLVED, _SANDBOX_EXTENSION_USER_INTENT, 
-                       __amkrtemp, __sandbox_in_a_container, _gpu_bundle_find_trusted, 
-                       _gpu_bundle_is_path_trusted, _kSBXProfileNoInternet, _kSBXProfileNoNetwork, 
-                       _kSBXProfileNoWrite, _kSBXProfileNoWriteExceptTemporary, _kSBXProfilePureComputation, 
-                       _rootless_allows_task_for_pid, _rootless_apply, _rootless_apply_internal, 
-                       _rootless_apply_relative, _rootless_check_datavault_flag, 
-                       _rootless_check_restricted_flag, _rootless_check_trusted, 
-                       _rootless_check_trusted_class, _rootless_check_trusted_fd, 
-                       _rootless_convert_to_datavault, _rootless_manifest_free, _rootless_manifest_parse, 
-                       _rootless_mkdir_datavault, _rootless_mkdir_nounlink, _rootless_mkdir_restricted, 
-                       _rootless_preflight, _rootless_protected_volume, _rootless_register_trusted_storage_class, 
-                       _rootless_restricted_environment, _rootless_suspend, _rootless_trusted_by_self_token, 
-                       _rootless_verify_trusted_by_self_token, _sandbox_check, _sandbox_check_bulk, 
-                       _sandbox_check_by_audit_token, _sandbox_check_by_reference, 
-                       _sandbox_check_by_uniqueid, _sandbox_consume_extension, _sandbox_consume_fs_extension, 
-                       _sandbox_consume_mach_extension, _sandbox_container_path_for_audit_token, 
-                       _sandbox_container_path_for_pid, _sandbox_extension_consume, 
-                       _sandbox_extension_issue_file, _sandbox_extension_issue_file_to_process, 
-                       _sandbox_extension_issue_file_to_process_by_pid, _sandbox_extension_issue_file_to_self, 
-                       _sandbox_extension_issue_generic, _sandbox_extension_issue_generic_to_process, 
-                       _sandbox_extension_issue_generic_to_process_by_pid, _sandbox_extension_issue_iokit_registry_entry_class, 
-                       _sandbox_extension_issue_iokit_registry_entry_class_to_process, 
-                       _sandbox_extension_issue_iokit_registry_entry_class_to_process_by_pid, 
-                       _sandbox_extension_issue_iokit_user_client_class, _sandbox_extension_issue_mach, 
-                       _sandbox_extension_issue_mach_to_process, _sandbox_extension_issue_mach_to_process_by_pid, 
-                       _sandbox_extension_issue_posix_ipc, _sandbox_extension_reap, 
-                       _sandbox_extension_release, _sandbox_extension_release_file, 
-                       _sandbox_extension_update_file, _sandbox_free_error, _sandbox_init, 
-                       _sandbox_init_from_pid, _sandbox_init_with_extensions, _sandbox_init_with_parameters, 
-                       _sandbox_issue_extension, _sandbox_issue_fs_extension, _sandbox_issue_fs_rw_extension, 
-                       _sandbox_issue_mach_extension, _sandbox_note, _sandbox_passthrough_access, 
-                       _sandbox_proc_getcontainer, _sandbox_proc_getprofilename, 
-                       _sandbox_query_approval_policy_for_path, _sandbox_query_user_intent_for_process_with_audit_token, 
-                       _sandbox_reference_release, _sandbox_reference_retain_by_audit_token, 
-                       _sandbox_release_fs_extension, _sandbox_requests_integrity_protection_for_preference_domain, 
-                       _sandbox_set_container_path_for_application_group, _sandbox_set_container_path_for_application_group_with_persona, 
-                       _sandbox_set_container_path_for_signing_id, _sandbox_set_container_path_for_signing_id_with_persona, 
-                       _sandbox_spawnattrs_getcontainer, _sandbox_spawnattrs_getprofilename, 
-                       _sandbox_spawnattrs_init, _sandbox_spawnattrs_setcontainer, 
-                       _sandbox_spawnattrs_setprofilename, _sandbox_suspend, _sandbox_unsuspend ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           F80872AA-E1FD-3D7E-8729-467656EC6561
-  - target:          x86_64-maccatalyst
-    value:           F80872AA-E1FD-3D7E-8729-467656EC6561
-install-name:    '/usr/lib/system/libsystem_secinit.dylib'
-current-version: 62.100.2
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ __libsecinit_initializer, _libsecinit_delete_all_data_container_content_for_current_user, 
-                       _libsecinit_fileoperation_save, _libsecinit_fileoperation_set_attributes, 
-                       _libsecinit_fileoperation_symlink ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           5820A2AF-CE72-3AB3-ABCC-273A3419FB55
-  - target:          x86_64-maccatalyst
-    value:           5820A2AF-CE72-3AB3-ABCC-273A3419FB55
-install-name:    '/usr/lib/system/libsystem_symptoms.dylib'
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ __symptoms_daemon_fallback_initial_disposition, __symptoms_daemon_fallback_subseq_disposition, 
-                       __symptoms_is_daemon_fallback_blacklisted, _symptom_framework_init, 
-                       _symptom_framework_set_version, _symptom_new, _symptom_send, 
-                       _symptom_send_immediate, _symptom_set_additional_qualifier, 
-                       _symptom_set_qualifier ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           04B47629-847B-3D74-8ABE-C05EF9DEEFE4
-  - target:          x86_64-maccatalyst
-    value:           04B47629-847B-3D74-8ABE-C05EF9DEEFE4
-install-name:    '/usr/lib/system/libsystem_trace.dylib'
-current-version: 1147.120
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ __libtrace_fork_child, __libtrace_init, __os_activity_create, 
-                       __os_activity_current, __os_activity_initiate, __os_activity_initiate_f, 
-                       __os_activity_label_useraction, __os_activity_none, __os_activity_set_breadcrumb, 
-                       __os_activity_start, __os_activity_stream_entry_encode, __os_log_create, 
-                       __os_log_debug, __os_log_debug_impl, __os_log_default, __os_log_disabled, 
-                       __os_log_error, __os_log_error_impl, __os_log_fault, __os_log_fault_impl, 
-                       __os_log_impl, __os_log_internal, __os_log_pack_fill, __os_log_pack_size, 
-                       __os_log_preferences_compute, __os_log_preferences_load, __os_log_release, 
-                       __os_log_set_nscf_formatter, __os_signpost_emit_impl, __os_signpost_emit_unreliably_impl, 
-                       __os_signpost_emit_unreliably_with_name_impl, __os_signpost_emit_with_name_impl, 
-                       __os_signpost_pack_fill, __os_signpost_pack_send, __os_state_request_for_pidlist, 
-                       __os_trace_atm_diagnostic_config, __os_trace_calloc, __os_trace_fdscandir_b, 
-                       __os_trace_get_boot_uuid, __os_trace_get_image_info, __os_trace_get_mode_for_pid, 
-                       __os_trace_get_times_now, __os_trace_intprefsdir_path, __os_trace_is_development_build, 
-                       __os_trace_log_simple, __os_trace_macho_for_each_slice, __os_trace_malloc, 
-                       __os_trace_memdup, __os_trace_mmap, __os_trace_mmap_at, __os_trace_mode_match_4tests, 
-                       __os_trace_prefs_latest_version_4tests, __os_trace_prefsdir_path, 
-                       __os_trace_read_file_at, __os_trace_read_plist_at, __os_trace_realloc, 
-                       __os_trace_scandir_free_namelist, __os_trace_set_diagnostic_flags, 
-                       __os_trace_set_mode_for_pid, __os_trace_strdup, __os_trace_sysprefsdir_path, 
-                       __os_trace_with_buffer, __os_trace_write, __os_trace_writev, 
-                       __os_trace_zalloc, _os_activity_apply, _os_activity_apply_f, 
-                       _os_activity_diagnostic_for_pid, _os_activity_end, _os_activity_for_task_thread, 
-                       _os_activity_for_thread, _os_activity_get_active, _os_activity_get_identifier, 
-                       _os_activity_iterate_activities, _os_activity_iterate_breadcrumbs, 
-                       _os_activity_iterate_messages, _os_activity_iterate_processes, 
-                       _os_activity_messages_for_thread, _os_activity_scope_enter, 
-                       _os_activity_scope_leave, _os_log_backtrace_copy_description, 
-                       _os_log_backtrace_copy_serialized_buffer, _os_log_backtrace_create_from_buffer, 
-                       _os_log_backtrace_create_from_current, _os_log_backtrace_create_from_pcs, 
-                       _os_log_backtrace_create_from_return_address, _os_log_backtrace_destroy, 
-                       _os_log_backtrace_get_frames, _os_log_backtrace_get_length, 
-                       _os_log_backtrace_print_to_blob, _os_log_backtrace_serialize_to_blob, 
-                       _os_log_create, _os_log_errors_count, _os_log_fault_default_callback, 
-                       _os_log_faults_count, _os_log_fmt_compose, _os_log_fmt_convert_trace, 
-                       _os_log_fmt_extract_pubdata, _os_log_fmt_get_plugin, _os_log_get_type, 
-                       _os_log_is_debug_enabled, _os_log_is_enabled, _os_log_pack_compose, 
-                       _os_log_pack_send, _os_log_pack_send_and_compose, _os_log_set_client_type, 
-                       _os_log_set_enabled, _os_log_set_fault_callback, _os_log_shim_enabled, 
-                       _os_log_shim_legacy_logging_enabled, _os_log_shim_with_CFString, 
-                       _os_log_type_enabled, _os_log_with_args, _os_signpost_enabled, 
-                       _os_signpost_id_generate, _os_signpost_id_make_with_pointer, 
-                       _os_signpost_set_introspection_hook_4Perf, _os_state_add_handler, 
-                       _os_state_remove_handler, _os_trace_add_task_mode, _os_trace_clear_task_mode, 
-                       _os_trace_debug_enabled, _os_trace_get_code, _os_trace_get_mode, 
-                       _os_trace_get_task_mode, _os_trace_get_type, _os_trace_info_enabled, 
-                       _os_trace_set_mode, _os_trace_set_task_mode ]
-    objc-classes:    [ OS_os_log ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           42B7B509-BAFE-365B-893A-72414C92F5BF
-  - target:          x86_64-maccatalyst
-    value:           42B7B509-BAFE-365B-893A-72414C92F5BF
-install-name:    '/usr/lib/system/libunwind.dylib'
-current-version: 35.4
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ '$ld$hide$os10.4$__Unwind_Backtrace', '$ld$hide$os10.4$__Unwind_DeleteException', 
-                       '$ld$hide$os10.4$__Unwind_FindEnclosingFunction', '$ld$hide$os10.4$__Unwind_Find_FDE', 
-                       '$ld$hide$os10.4$__Unwind_ForcedUnwind', '$ld$hide$os10.4$__Unwind_GetCFA', 
-                       '$ld$hide$os10.4$__Unwind_GetDataRelBase', '$ld$hide$os10.4$__Unwind_GetGR', 
-                       '$ld$hide$os10.4$__Unwind_GetIP', '$ld$hide$os10.4$__Unwind_GetIPInfo', 
-                       '$ld$hide$os10.4$__Unwind_GetLanguageSpecificData', '$ld$hide$os10.4$__Unwind_GetRegionStart', 
-                       '$ld$hide$os10.4$__Unwind_GetTextRelBase', '$ld$hide$os10.4$__Unwind_RaiseException', 
-                       '$ld$hide$os10.4$__Unwind_Resume', '$ld$hide$os10.4$__Unwind_Resume_or_Rethrow', 
-                       '$ld$hide$os10.4$__Unwind_SetGR', '$ld$hide$os10.4$__Unwind_SetIP', 
-                       '$ld$hide$os10.4$___deregister_frame', '$ld$hide$os10.4$___deregister_frame_info', 
-                       '$ld$hide$os10.4$___deregister_frame_info_bases', '$ld$hide$os10.4$___register_frame', 
-                       '$ld$hide$os10.4$___register_frame_info', '$ld$hide$os10.4$___register_frame_info_bases', 
-                       '$ld$hide$os10.4$___register_frame_info_table', '$ld$hide$os10.4$___register_frame_info_table_bases', 
-                       '$ld$hide$os10.4$___register_frame_table', '$ld$hide$os10.5$__Unwind_Backtrace', 
-                       '$ld$hide$os10.5$__Unwind_DeleteException', '$ld$hide$os10.5$__Unwind_FindEnclosingFunction', 
-                       '$ld$hide$os10.5$__Unwind_Find_FDE', '$ld$hide$os10.5$__Unwind_ForcedUnwind', 
-                       '$ld$hide$os10.5$__Unwind_GetCFA', '$ld$hide$os10.5$__Unwind_GetDataRelBase', 
-                       '$ld$hide$os10.5$__Unwind_GetGR', '$ld$hide$os10.5$__Unwind_GetIP', 
-                       '$ld$hide$os10.5$__Unwind_GetIPInfo', '$ld$hide$os10.5$__Unwind_GetLanguageSpecificData', 
-                       '$ld$hide$os10.5$__Unwind_GetRegionStart', '$ld$hide$os10.5$__Unwind_GetTextRelBase', 
-                       '$ld$hide$os10.5$__Unwind_RaiseException', '$ld$hide$os10.5$__Unwind_Resume', 
-                       '$ld$hide$os10.5$__Unwind_Resume_or_Rethrow', '$ld$hide$os10.5$__Unwind_SetGR', 
-                       '$ld$hide$os10.5$__Unwind_SetIP', '$ld$hide$os10.5$___deregister_frame', 
-                       '$ld$hide$os10.5$___deregister_frame_info', '$ld$hide$os10.5$___deregister_frame_info_bases', 
-                       '$ld$hide$os10.5$___register_frame', '$ld$hide$os10.5$___register_frame_info', 
-                       '$ld$hide$os10.5$___register_frame_info_bases', '$ld$hide$os10.5$___register_frame_info_table', 
-                       '$ld$hide$os10.5$___register_frame_info_table_bases', '$ld$hide$os10.5$___register_frame_table', 
-                       '$ld$hide$os10.6$___deregister_frame_info', '$ld$hide$os10.6$___deregister_frame_info_bases', 
-                       '$ld$hide$os10.6$___register_frame_info', '$ld$hide$os10.6$___register_frame_info_bases', 
-                       '$ld$hide$os10.6$___register_frame_info_table', '$ld$hide$os10.6$___register_frame_info_table_bases', 
-                       '$ld$hide$os10.6$___register_frame_table', __Unwind_Backtrace, 
-                       __Unwind_DeleteException, __Unwind_FindEnclosingFunction, 
-                       __Unwind_Find_FDE, __Unwind_ForcedUnwind, __Unwind_GetCFA, 
-                       __Unwind_GetDataRelBase, __Unwind_GetGR, __Unwind_GetIP, __Unwind_GetIPInfo, 
-                       __Unwind_GetLanguageSpecificData, __Unwind_GetRegionStart, 
-                       __Unwind_GetTextRelBase, __Unwind_RaiseException, __Unwind_Resume, 
-                       __Unwind_Resume_or_Rethrow, __Unwind_SetGR, __Unwind_SetIP, 
-                       ___deregister_frame, ___deregister_frame_info, ___deregister_frame_info_bases, 
-                       ___register_frame, ___register_frame_info, ___register_frame_info_bases, 
-                       ___register_frame_info_table, ___register_frame_info_table_bases, 
-                       ___register_frame_table, _unw_get_fpreg, _unw_get_proc_info, 
-                       _unw_get_proc_name, _unw_get_reg, _unw_getcontext, _unw_init_local, 
-                       _unw_is_fpreg, _unw_is_signal_frame, _unw_iterate_dwarf_unwind_cache, 
-                       _unw_regname, _unw_resume, _unw_set_fpreg, _unw_set_reg, _unw_step ]
---- !tapi-tbd
-tbd-version:     4
-targets:         [ x86_64-macos, x86_64-maccatalyst ]
-uuids:
-  - target:          x86_64-macos
-    value:           3E243A41-030F-38E3-9FD2-7B38C66C35B1
-  - target:          x86_64-maccatalyst
-    value:           3E243A41-030F-38E3-9FD2-7B38C66C35B1
-install-name:    '/usr/lib/system/libxpc.dylib'
-current-version: 1738.140.1
-parent-umbrella:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    umbrella:        System
-exports:
-  - targets:         [ x86_64-macos, x86_64-maccatalyst ]
-    symbols:         [ _XPC_ACTIVITY_ALLOW_BATTERY, _XPC_ACTIVITY_APP_REFRESH, _XPC_ACTIVITY_CHECK_IN, 
-                       _XPC_ACTIVITY_COMMUNICATES_WITH_PAIRED_DEVICE, _XPC_ACTIVITY_CPU_INTENSIVE, 
-                       _XPC_ACTIVITY_DELAY, _XPC_ACTIVITY_DESIRED_MOTION_STATE, _XPC_ACTIVITY_DISK_INTENSIVE, 
-                       _XPC_ACTIVITY_DO_IT_LATER, _XPC_ACTIVITY_DUET_ACTIVITY_SCHEDULER_DATA, 
-                       _XPC_ACTIVITY_DUET_ATTRIBUTE_COST, _XPC_ACTIVITY_DUET_ATTRIBUTE_NAME, 
-                       _XPC_ACTIVITY_DUET_ATTRIBUTE_VALUE, _XPC_ACTIVITY_DUET_RELATED_APPLICATIONS, 
-                       _XPC_ACTIVITY_EXCLUSIVE, _XPC_ACTIVITY_EXPECTED_DURATION, 
-                       _XPC_ACTIVITY_GRACE_PERIOD, _XPC_ACTIVITY_GROUP_CONCURRENCY_LIMIT, 
-                       _XPC_ACTIVITY_GROUP_NAME, _XPC_ACTIVITY_INTERVAL, _XPC_ACTIVITY_INTERVAL_15_MIN, 
-                       _XPC_ACTIVITY_INTERVAL_1_DAY, _XPC_ACTIVITY_INTERVAL_1_HOUR, 
-                       _XPC_ACTIVITY_INTERVAL_1_MIN, _XPC_ACTIVITY_INTERVAL_30_MIN, 
-                       _XPC_ACTIVITY_INTERVAL_4_HOURS, _XPC_ACTIVITY_INTERVAL_5_MIN, 
-                       _XPC_ACTIVITY_INTERVAL_7_DAYS, _XPC_ACTIVITY_INTERVAL_8_HOURS, 
-                       _XPC_ACTIVITY_MAY_REBOOT_DEVICE, _XPC_ACTIVITY_MEMORY_INTENSIVE, 
-                       _XPC_ACTIVITY_MOTION_STATE_AUTOMOTIVE, _XPC_ACTIVITY_MOTION_STATE_AUTOMOTIVE_MOVING, 
-                       _XPC_ACTIVITY_MOTION_STATE_AUTOMOTIVE_STATIONARY, _XPC_ACTIVITY_MOTION_STATE_CYCLING, 
-                       _XPC_ACTIVITY_MOTION_STATE_RUNNING, _XPC_ACTIVITY_MOTION_STATE_STATIONARY, 
-                       _XPC_ACTIVITY_MOTION_STATE_WALKING, _XPC_ACTIVITY_NETWORK_TRANSFER_BIDIRECTIONAL, 
-                       _XPC_ACTIVITY_NETWORK_TRANSFER_DIRECTION, _XPC_ACTIVITY_NETWORK_TRANSFER_DIRECTION_DOWNLOAD, 
-                       _XPC_ACTIVITY_NETWORK_TRANSFER_DIRECTION_UPLOAD, _XPC_ACTIVITY_NETWORK_TRANSFER_ENDPOINT, 
-                       _XPC_ACTIVITY_NETWORK_TRANSFER_PARAMETERS, _XPC_ACTIVITY_NETWORK_TRANSFER_SIZE, 
-                       _XPC_ACTIVITY_POST_INSTALL, _XPC_ACTIVITY_POWER_NAP, _XPC_ACTIVITY_PRIORITY, 
-                       _XPC_ACTIVITY_PRIORITY_MAINTENANCE, _XPC_ACTIVITY_PRIORITY_UTILITY, 
-                       _XPC_ACTIVITY_RANDOM_INITIAL_DELAY, _XPC_ACTIVITY_REPEATING, 
-                       _XPC_ACTIVITY_REPLY_ENDPOINT, _XPC_ACTIVITY_REQUIRES_BUDDY_COMPLETE, 
-                       _XPC_ACTIVITY_REQUIRES_CLASS_A, _XPC_ACTIVITY_REQUIRES_CLASS_B, 
-                       _XPC_ACTIVITY_REQUIRES_CLASS_C, _XPC_ACTIVITY_REQUIRE_BATTERY_LEVEL, 
-                       _XPC_ACTIVITY_REQUIRE_HDD_SPINNING, _XPC_ACTIVITY_REQUIRE_INEXPENSIVE_NETWORK_CONNECTIVITY, 
-                       _XPC_ACTIVITY_REQUIRE_NETWORK_CONNECTIVITY, _XPC_ACTIVITY_REQUIRE_SCREEN_SLEEP, 
-                       _XPC_ACTIVITY_REQUIRE_SIGNIFICANT_USER_INACTIVITY, _XPC_ACTIVITY_SEQUENCE_NUMBER, 
-                       _XPC_ACTIVITY_SHOULD_WAKE_DEVICE, _XPC_ACTIVITY_USER_REQUESTED_BACKUP_TASK, 
-                       _XPC_ACTIVITY_USES_DUET_POWER_BUDGETING, _XPC_COALITION_INFO_KEY_BUNDLE_IDENTIFIER, 
-                       _XPC_COALITION_INFO_KEY_CID, _XPC_COALITION_INFO_KEY_NAME, 
-                       _XPC_COALITION_INFO_KEY_RESOURCE_USAGE_BLOB, __availability_version_check, 
-                       __launch_msg2, __launch_service_stats_copy_4ppse_impl, __libxpc_initializer, 
-                       __spawn_via_launchd, __system_ios_support_version_copy_string_sysctl, 
-                       __system_version_copy_string_plist, __system_version_copy_string_sysctl, 
-                       __system_version_fallback, __system_version_parse_string, 
-                       __vproc_get_last_exit_status, __vproc_grab_subset, __vproc_kickstart_by_label, 
-                       __vproc_log, __vproc_log_error, __vproc_logv, __vproc_pid_is_managed, 
-                       __vproc_post_fork_ping, __vproc_send_signal_by_label, __vproc_set_global_on_demand, 
-                       __vproc_standby_begin, __vproc_standby_count, __vproc_standby_end, 
-                       __vproc_standby_timeout, __vproc_transaction_begin, __vproc_transaction_count, 
-                       __vproc_transaction_count_for_pid, __vproc_transaction_end, 
-                       __vproc_transaction_set_clean_callback, __vproc_transaction_try_exit, 
-                       __vproc_transactions_enable, __vprocmgr_detach_from_console, 
-                       __vprocmgr_getsocket, __vprocmgr_init, __vprocmgr_log_drain, 
-                       __vprocmgr_log_forward, __vprocmgr_move_subset_to_user, __vprocmgr_switch_to_session, 
-                       __xpc_bool_create_distinct, __xpc_bool_false, __xpc_bool_set_value, 
-                       __xpc_bool_true, __xpc_connection_set_event_handler_f, __xpc_data_set_value, 
-                       __xpc_dictionary_create_reply_with_port, __xpc_dictionary_extract_mach_send, 
-                       __xpc_dictionary_extract_reply_msg_id, __xpc_dictionary_extract_reply_port, 
-                       __xpc_dictionary_get_reply_msg_id, __xpc_dictionary_set_remote_connection, 
-                       __xpc_dictionary_set_reply_msg_id, __xpc_double_set_value, 
-                       __xpc_error_connection_interrupted, __xpc_error_connection_invalid, 
-                       __xpc_error_key_description, __xpc_error_termination_imminent, 
-                       __xpc_event_key_name, __xpc_event_key_stream_name, __xpc_fd_get_port, 
-                       __xpc_int64_set_value, __xpc_payload_create_from_mach_msg, 
-                       __xpc_pipe_handle_mig, __xpc_runtime_get_entitlements_data, 
-                       __xpc_runtime_get_self_entitlements, __xpc_runtime_is_app_sandboxed, 
-                       __xpc_service_last_xref_cancel, __xpc_shmem_get_mach_port, 
-                       __xpc_spawnattr_pack_string, __xpc_spawnattr_pack_string_fragment, 
-                       __xpc_spawnattr_unpack_string, __xpc_spawnattr_unpack_strings, 
-                       __xpc_string_set_value, __xpc_type_activity, __xpc_type_array, 
-                       __xpc_type_base, __xpc_type_bool, __xpc_type_bundle, __xpc_type_connection, 
-                       __xpc_type_data, __xpc_type_date, __xpc_type_dictionary, __xpc_type_double, 
-                       __xpc_type_endpoint, __xpc_type_error, __xpc_type_fd, __xpc_type_file_transfer, 
-                       __xpc_type_int64, __xpc_type_mach_recv, __xpc_type_mach_send, 
-                       __xpc_type_null, __xpc_type_pipe, __xpc_type_pointer, __xpc_type_serializer, 
-                       __xpc_type_service, __xpc_type_service_instance, __xpc_type_shmem, 
-                       __xpc_type_string, __xpc_type_uint64, __xpc_type_uuid, _bootstrap_check_in, 
-                       _bootstrap_check_in2, _bootstrap_check_in3, _bootstrap_create_server, 
-                       _bootstrap_create_service, _bootstrap_get_root, _bootstrap_info, 
-                       _bootstrap_init, _bootstrap_look_up, _bootstrap_look_up2, 
-                       _bootstrap_look_up3, _bootstrap_look_up_per_user, _bootstrap_lookup_children, 
-                       _bootstrap_parent, _bootstrap_register, _bootstrap_register2, 
-                       _bootstrap_status, _bootstrap_strerror, _bootstrap_subset, 
-                       _bootstrap_unprivileged, _create_and_switch_to_per_session_launchd, 
-                       _launch_activate_socket, _launch_add_external_service, _launch_bootout_user_service_4coresim, 
-                       _launch_copy_busy_extension_instances, _launch_copy_endpoints_properties_for_pid, 
-                       _launch_copy_extension_properties, _launch_copy_extension_properties_for_pid, 
-                       _launch_copy_properties_for_pid_4assertiond, _launch_create_persona, 
-                       _launch_data_alloc, _launch_data_array_get_count, _launch_data_array_get_index, 
-                       _launch_data_array_set_index, _launch_data_copy, _launch_data_dict_get_count, 
-                       _launch_data_dict_insert, _launch_data_dict_iterate, _launch_data_dict_lookup, 
-                       _launch_data_dict_remove, _launch_data_free, _launch_data_get_bool, 
-                       _launch_data_get_errno, _launch_data_get_fd, _launch_data_get_integer, 
-                       _launch_data_get_machport, _launch_data_get_opaque, _launch_data_get_opaque_size, 
-                       _launch_data_get_real, _launch_data_get_string, _launch_data_get_type, 
-                       _launch_data_new_bool, _launch_data_new_errno, _launch_data_new_fd, 
-                       _launch_data_new_integer, _launch_data_new_machport, _launch_data_new_opaque, 
-                       _launch_data_new_real, _launch_data_new_string, _launch_data_pack, 
-                       _launch_data_set_bool, _launch_data_set_errno, _launch_data_set_fd, 
-                       _launch_data_set_integer, _launch_data_set_machport, _launch_data_set_opaque, 
-                       _launch_data_set_real, _launch_data_set_string, _launch_data_unpack, 
-                       _launch_destroy_persona, _launch_disable_directory, _launch_enable_directory, 
-                       _launch_extension_check_in_live_4UIKit, _launch_extension_property_bundle_id, 
-                       _launch_extension_property_host_bundle_id, _launch_extension_property_host_pid, 
-                       _launch_extension_property_path, _launch_extension_property_pid, 
-                       _launch_extension_property_version, _launch_extension_property_xpc_bundle, 
-                       _launch_get_fd, _launch_get_service_enabled, _launch_get_system_service_enabled, 
-                       _launch_msg, _launch_path_for_user_service_4coresim, _launch_perfcheck_property_endpoint_active, 
-                       _launch_perfcheck_property_endpoint_event, _launch_perfcheck_property_endpoint_name, 
-                       _launch_perfcheck_property_endpoint_needs_activation, _launch_perfcheck_property_endpoints, 
-                       _launch_remove_external_service, _launch_service_stats_disable_4ppse, 
-                       _launch_service_stats_enable_4ppse, _launch_service_stats_is_enabled_4ppse, 
-                       _launch_set_service_enabled, _launch_set_system_service_enabled, 
-                       _launch_socket_service_check_in, _launch_version_for_user_service_4coresim, 
-                       _launch_wait, _launchd_close, _launchd_fdopen, _launchd_getfd, 
-                       _launchd_msg_recv, _launchd_msg_send, _load_launchd_jobs_at_loginwindow_prompt, 
-                       _mpm_uncork_fork, _mpm_wait, _os_system_version_get_current_version, 
-                       _os_system_version_sim_get_current_host_version, _os_transaction_copy_description, 
-                       _os_transaction_create, _os_transaction_needs_more_time, _place_hold_on_real_loginwindow, 
-                       _reboot2, _reboot3, _vproc_release, _vproc_retain, _vproc_standby_begin, 
-                       _vproc_standby_end, _vproc_swap_complex, _vproc_swap_integer, 
-                       _vproc_swap_string, _vproc_transaction_begin, _vproc_transaction_end, 
-                       _vprocmgr_lookup_vproc, _xpc_activity_add_eligibility_changed_handler, 
-                       _xpc_activity_copy_criteria, _xpc_activity_copy_dispatch_queue, 
-                       _xpc_activity_copy_identifier, _xpc_activity_debug, _xpc_activity_defer_until_network_change, 
-                       _xpc_activity_defer_until_percentage, _xpc_activity_get_percentage, 
-                       _xpc_activity_get_state, _xpc_activity_list, _xpc_activity_register, 
-                       _xpc_activity_remove_eligibility_changed_handler, _xpc_activity_run, 
-                       _xpc_activity_set_completion_status, _xpc_activity_set_criteria, 
-                       _xpc_activity_set_network_threshold, _xpc_activity_set_state, 
-                       _xpc_activity_should_defer, _xpc_activity_unregister, _xpc_add_bundle, 
-                       _xpc_add_bundles_for_domain, _xpc_array_append_value, _xpc_array_apply, 
-                       _xpc_array_apply_f, _xpc_array_copy_mach_send, _xpc_array_create, 
-                       _xpc_array_create_connection, _xpc_array_dup_fd, _xpc_array_get_array, 
-                       _xpc_array_get_bool, _xpc_array_get_count, _xpc_array_get_data, 
-                       _xpc_array_get_date, _xpc_array_get_dictionary, _xpc_array_get_double, 
-                       _xpc_array_get_int64, _xpc_array_get_pointer, _xpc_array_get_string, 
-                       _xpc_array_get_uint64, _xpc_array_get_uuid, _xpc_array_get_value, 
-                       _xpc_array_set_bool, _xpc_array_set_connection, _xpc_array_set_data, 
-                       _xpc_array_set_date, _xpc_array_set_double, _xpc_array_set_fd, 
-                       _xpc_array_set_int64, _xpc_array_set_mach_send, _xpc_array_set_pointer, 
-                       _xpc_array_set_string, _xpc_array_set_uint64, _xpc_array_set_uuid, 
-                       _xpc_array_set_value, _xpc_atfork_child, _xpc_atfork_parent, 
-                       _xpc_atfork_prepare, _xpc_bool_create, _xpc_bool_get_value, 
-                       _xpc_bundle_copy_info_dictionary, _xpc_bundle_copy_resource_path, 
-                       _xpc_bundle_copy_services, _xpc_bundle_create, _xpc_bundle_create_from_origin, 
-                       _xpc_bundle_create_main, _xpc_bundle_get_error, _xpc_bundle_get_executable_path, 
-                       _xpc_bundle_get_info_dictionary, _xpc_bundle_get_path, _xpc_bundle_get_property, 
-                       _xpc_bundle_get_xpcservice_dictionary, _xpc_bundle_populate, 
-                       _xpc_bundle_resolve, _xpc_bundle_resolve_on_queue, _xpc_bundle_resolve_sync, 
-                       _xpc_coalition_copy_info, _xpc_coalition_history_pipe_async, 
-                       _xpc_connection_activate, _xpc_connection_cancel, _xpc_connection_copy_bundle_id, 
-                       _xpc_connection_copy_entitlement_value, _xpc_connection_create, 
-                       _xpc_connection_create_from_endpoint, _xpc_connection_create_listener, 
-                       _xpc_connection_create_mach_service, _xpc_connection_enable_sim2host_4sim, 
-                       _xpc_connection_enable_termination_imminent_event, _xpc_connection_get_asid, 
-                       _xpc_connection_get_audit_token, _xpc_connection_get_bs_type, 
-                       _xpc_connection_get_context, _xpc_connection_get_egid, _xpc_connection_get_euid, 
-                       _xpc_connection_get_instance, _xpc_connection_get_name, _xpc_connection_get_pid, 
-                       _xpc_connection_is_extension, _xpc_connection_kill, _xpc_connection_resume, 
-                       _xpc_connection_send_barrier, _xpc_connection_send_message, 
-                       _xpc_connection_send_message_with_reply, _xpc_connection_send_message_with_reply_sync, 
-                       _xpc_connection_send_notification, _xpc_connection_set_bootstrap, 
-                       _xpc_connection_set_bs_type, _xpc_connection_set_context, 
-                       _xpc_connection_set_event_channel, _xpc_connection_set_event_handler, 
-                       _xpc_connection_set_finalizer_f, _xpc_connection_set_instance, 
-                       _xpc_connection_set_legacy, _xpc_connection_set_non_launching, 
-                       _xpc_connection_set_oneshot_instance, _xpc_connection_set_privileged, 
-                       _xpc_connection_set_qos_class_fallback, _xpc_connection_set_qos_class_floor, 
-                       _xpc_connection_set_target_queue, _xpc_connection_set_target_uid, 
-                       _xpc_connection_suspend, _xpc_copy, _xpc_copy_bootstrap, _xpc_copy_clean_description, 
-                       _xpc_copy_code_signing_identity_for_token, _xpc_copy_debug_description, 
-                       _xpc_copy_description, _xpc_copy_domain, _xpc_copy_entitlement_for_self, 
-                       _xpc_copy_entitlement_for_token, _xpc_copy_entitlements_data_for_token, 
-                       _xpc_copy_entitlements_for_pid, _xpc_copy_entitlements_for_self, 
-                       _xpc_copy_event, _xpc_copy_event_entitlements, _xpc_copy_extension_sdk_entry, 
-                       _xpc_copy_short_description, _xpc_create_from_plist, _xpc_create_from_plist_descriptor, 
-                       _xpc_create_from_serialization, _xpc_create_from_serialization_with_ool, 
-                       _xpc_create_reply_with_format, _xpc_create_reply_with_format_and_arguments, 
-                       _xpc_create_with_format, _xpc_create_with_format_and_arguments, 
-                       _xpc_data_create, _xpc_data_create_with_dispatch_data, _xpc_data_get_bytes, 
-                       _xpc_data_get_bytes_ptr, _xpc_data_get_inline_max, _xpc_data_get_length, 
-                       _xpc_date_create, _xpc_date_create_absolute, _xpc_date_create_from_current, 
-                       _xpc_date_get_value, _xpc_date_get_value_absolute, _xpc_date_is_int64_range, 
-                       _xpc_dictionary_apply, _xpc_dictionary_apply_f, _xpc_dictionary_copy_basic_description, 
-                       _xpc_dictionary_copy_mach_send, _xpc_dictionary_create, _xpc_dictionary_create_connection, 
-                       _xpc_dictionary_create_reply, _xpc_dictionary_dup_fd, _xpc_dictionary_expects_reply, 
-                       _xpc_dictionary_extract_mach_recv, _xpc_dictionary_get_array, 
-                       _xpc_dictionary_get_audit_token, _xpc_dictionary_get_bool, 
-                       _xpc_dictionary_get_connection, _xpc_dictionary_get_count, 
-                       _xpc_dictionary_get_data, _xpc_dictionary_get_date, _xpc_dictionary_get_dictionary, 
-                       _xpc_dictionary_get_double, _xpc_dictionary_get_int64, _xpc_dictionary_get_pointer, 
-                       _xpc_dictionary_get_remote_connection, _xpc_dictionary_get_string, 
-                       _xpc_dictionary_get_uint64, _xpc_dictionary_get_uuid, _xpc_dictionary_get_value, 
-                       _xpc_dictionary_handoff_reply, _xpc_dictionary_handoff_reply_f, 
-                       _xpc_dictionary_send_reply, _xpc_dictionary_set_bool, _xpc_dictionary_set_connection, 
-                       _xpc_dictionary_set_data, _xpc_dictionary_set_date, _xpc_dictionary_set_double, 
-                       _xpc_dictionary_set_fd, _xpc_dictionary_set_int64, _xpc_dictionary_set_mach_recv, 
-                       _xpc_dictionary_set_mach_send, _xpc_dictionary_set_pointer, 
-                       _xpc_dictionary_set_string, _xpc_dictionary_set_uint64, _xpc_dictionary_set_uuid, 
-                       _xpc_dictionary_set_value, _xpc_double_create, _xpc_double_get_value, 
-                       _xpc_endpoint_compare, _xpc_endpoint_copy_listener_port_4sim, 
-                       _xpc_endpoint_create, _xpc_endpoint_create_bs_named, _xpc_endpoint_create_mach_port_4sim, 
-                       _xpc_equal, _xpc_event_publisher_activate, _xpc_event_publisher_create, 
-                       _xpc_event_publisher_fire, _xpc_event_publisher_fire_noboost, 
-                       _xpc_event_publisher_fire_with_reply, _xpc_event_publisher_fire_with_reply_sync, 
-                       _xpc_event_publisher_get_subscriber_asid, _xpc_event_publisher_set_error_handler, 
-                       _xpc_event_publisher_set_handler, _xpc_event_publisher_set_initial_load_completed_handler_4remoted, 
-                       _xpc_event_publisher_set_subscriber_keepalive, _xpc_event_stream_check_in, 
-                       _xpc_event_stream_check_in2, _xpc_exit_reason_get_label, _xpc_extension_type_init, 
-                       _xpc_fd_create, _xpc_fd_dup, _xpc_file_transfer_cancel, _xpc_file_transfer_copy_io, 
-                       _xpc_file_transfer_create_with_fd, _xpc_file_transfer_create_with_path, 
-                       _xpc_file_transfer_get_size, _xpc_file_transfer_get_transfer_id, 
-                       _xpc_file_transfer_send_finished, _xpc_file_transfer_set_transport_writing_callbacks, 
-                       _xpc_file_transfer_write_finished, _xpc_file_transfer_write_to_fd, 
-                       _xpc_file_transfer_write_to_path, _xpc_generate_audit_token, 
-                       _xpc_get_attachment_endpoint, _xpc_get_class4NSXPC, _xpc_get_event_name, 
-                       _xpc_get_type, _xpc_handle_service, _xpc_handle_subservice, 
-                       _xpc_hash, _xpc_impersonate_user, _xpc_init_services, _xpc_inspect_copy_description, 
-                       _xpc_inspect_copy_description_local, _xpc_inspect_copy_short_description, 
-                       _xpc_inspect_copy_short_description_local, _xpc_install_remote_hooks, 
-                       _xpc_int64_create, _xpc_int64_get_value, _xpc_is_kind_of_xpc_object4NSXPC, 
-                       _xpc_mach_recv_create, _xpc_mach_recv_extract_right, _xpc_mach_send_copy_right, 
-                       _xpc_mach_send_create, _xpc_mach_send_create_with_disposition, 
-                       _xpc_mach_send_get_right, _xpc_main, _xpc_make_serialization, 
-                       _xpc_make_serialization_with_ool, _xpc_null_create, _xpc_pipe_create, 
-                       _xpc_pipe_create_from_port, _xpc_pipe_invalidate, _xpc_pipe_receive, 
-                       _xpc_pipe_routine, _xpc_pipe_routine_async, _xpc_pipe_routine_forward, 
-                       _xpc_pipe_routine_reply, _xpc_pipe_routine_with_flags, _xpc_pipe_simpleroutine, 
-                       _xpc_pipe_try_receive, _xpc_pointer_create, _xpc_pointer_get_value, 
-                       _xpc_receive_mach_msg, _xpc_receive_remote_msg, _xpc_release, 
-                       _xpc_retain, _xpc_service_attach, _xpc_service_create, _xpc_service_create_from_specifier, 
-                       _xpc_service_get_rendezvous_token, _xpc_service_instance_dup2, 
-                       _xpc_service_instance_get_context, _xpc_service_instance_get_host_pid, 
-                       _xpc_service_instance_get_pid, _xpc_service_instance_get_type, 
-                       _xpc_service_instance_is_configurable, _xpc_service_instance_run, 
-                       _xpc_service_instance_set_binpref, _xpc_service_instance_set_context, 
-                       _xpc_service_instance_set_cwd, _xpc_service_instance_set_endpoint, 
-                       _xpc_service_instance_set_environment, _xpc_service_instance_set_finalizer_f, 
-                       _xpc_service_instance_set_jetsam_properties, _xpc_service_instance_set_path, 
-                       _xpc_service_instance_set_start_suspended, _xpc_service_kickstart, 
-                       _xpc_service_set_attach_handler, _xpc_set_event, _xpc_set_event_state, 
-                       _xpc_set_event_stream_handler, _xpc_set_event_with_flags, 
-                       _xpc_set_idle_handler, _xpc_shmem_create, _xpc_shmem_create_readonly, 
-                       _xpc_shmem_get_length, _xpc_shmem_map, _xpc_strerror, _xpc_string_create, 
-                       _xpc_string_create_no_copy, _xpc_string_create_with_format, 
-                       _xpc_string_create_with_format_and_arguments, _xpc_string_get_length, 
-                       _xpc_string_get_string_ptr, _xpc_test_symbols_exported, _xpc_track_activity, 
-                       _xpc_transaction_begin, _xpc_transaction_end, _xpc_transaction_exit_clean, 
-                       _xpc_transaction_interrupt_clean_exit, _xpc_transactions_enable, 
-                       _xpc_type_get_name, _xpc_uint64_create, _xpc_uint64_get_value, 
-                       _xpc_uuid_create, _xpc_uuid_get_bytes ]
-    objc-classes:    [ OS_xpc_object ]
-...

From 304eb54169ad9b6d7fc278807df39ef68e76202f Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Tue, 25 Oct 2022 16:16:22 +0200
Subject: [PATCH 12/70] darwin: update macOS libc headers

Add aarch64-macos.13 and x86_64-macos.13 libc headers, and remove
x86_64-macos.10 headers.
---
 .../aarch64-macos.13-none/arm/_limits.h       |   13 +
 .../aarch64-macos.13-none/arm/_mcontext.h     |   95 +
 .../aarch64-macos.13-none/arm/_param.h        |   25 +
 .../aarch64-macos.13-none/arm/_types.h        |  102 +
 .../arm/arch.h}                               |   53 +-
 .../aarch64-macos.13-none/arm/endian.h        |   81 +
 .../aarch64-macos.13-none/arm/limits.h        |  114 +
 .../include/aarch64-macos.13-none/arm/param.h |  151 +
 .../aarch64-macos.13-none/arm/signal.h        |   22 +
 .../include/aarch64-macos.13-none/arm/types.h |  111 +
 .../libkern/OSAtomic.h                        |    0
 .../libkern/OSAtomicDeprecated.h              |  113 +-
 .../libkern/OSAtomicQueue.h                   |   78 +-
 .../libkern/OSSpinLockDeprecated.h            |    0
 .../libkern/arm/OSByteOrder.h                 |  216 +
 .../aarch64-macos.13-none/mach/arm/_structs.h |  683 ++
 .../mach/arm/boolean.h}                       |   23 +-
 .../mach/arm/exception.h                      |   82 +
 .../mach/arm/kern_return.h}                   |   39 +-
 .../mach/arm/processor_info.h                 |   76 +
 .../mach/arm}/rpc.h                           |   17 +-
 .../mach/arm/thread_state.h}                  |   20 +-
 .../mach/arm/thread_status.h                  |  236 +
 .../aarch64-macos.13-none/mach/arm/vm_param.h |  112 +
 .../aarch64-macos.13-none/mach/arm/vm_types.h |  162 +
 .../TargetConditionals.h                      |    0
 .../mach/mach_init.h                          |    0
 .../mach/task_info.h                          |    0
 .../spawn.h                                   |    0
 .../sys/attr.h                                |    0
 lib/libc/include/any-macos-any/sys/stdio.h    |   11 +-
 .../time.h                                    |    0
 .../copyfile.h                                |    0
 .../sys/stdio.h                               |   11 +-
 .../sys/unistd.h                              |    0
 .../Availability.h                            |  163 +-
 .../AvailabilityInternal.h                    |   47 +-
 .../AvailabilityMacros.h                      |   13 +-
 .../any-macos.13-any/AvailabilityVersions.h   |  255 +
 lib/libc/include/any-macos.13-any/Block.h     |   65 +
 lib/libc/include/any-macos.13-any/copyfile.h  |  137 +
 .../dispatch/base.h                           |   45 +
 .../dispatch/block.h                          |    6 +-
 .../include/any-macos.13-any/dispatch/data.h  |  280 +
 .../dispatch/group.h                          |    4 +-
 .../include/any-macos.13-any/dispatch/io.h    |  599 ++
 .../dispatch/object.h                         |   12 +-
 .../include/any-macos.13-any/dispatch/once.h  |  127 +
 .../dispatch/queue.h                          |   23 +-
 .../dispatch/semaphore.h                      |   12 +-
 .../dispatch/source.h                         |   12 +-
 .../include/any-macos.13-any/dispatch/time.h  |  138 +
 .../dispatch/workloop.h                       |   37 +-
 lib/libc/include/any-macos.13-any/dlfcn.h     |   97 +
 lib/libc/include/any-macos.13-any/launch.h    |  411 +
 .../libproc.h                                 |   49 +-
 .../include/any-macos.13-any/mach-o/arch.h    |  159 +
 .../include/any-macos.13-any/mach-o/fat.h     |   86 +
 .../mach-o/loader.h                           |   91 +-
 .../mach/clock.h                              |    8 +-
 .../mach/clock_priv.h                         |    8 +-
 .../mach/exception_types.h                    |   22 +-
 .../mach/host_priv.h                          |    8 +-
 .../mach/host_security.h                      |    8 +-
 .../mach/host_special_ports.h                 |   28 +-
 .../mach/mach.h                               |    6 +-
 .../mach/mach_host.h                          |   47 +-
 .../mach/mach_interface.h}                    |   37 +-
 .../mach/mach_port.h                          |  164 +-
 .../mach/mach_types.h                         |   50 +-
 .../mach/mach_voucher_types.h                 |    9 +-
 .../mach/machine.h                            |   26 +-
 .../mach/message.h                            |  109 +-
 .../mach/port.h                               |   95 +-
 .../mach/processor.h                          |    8 +-
 .../any-macos.13-any/mach/processor_info.h    |  156 +
 .../mach/processor_set.h                      |   57 +-
 .../mach/task.h                               |  488 +-
 .../mach/task_policy.h                        |    9 +-
 .../mach/thread_act.h                         |  171 +-
 .../mach/thread_policy.h                      |   14 +-
 .../mach/vm_map.h                             |  100 +-
 .../mach/vm_prot.h                            |   30 +-
 .../mach/vm_statistics.h                      |   81 +-
 .../mach/vm_types.h                           |   23 +-
 .../mach_debug/ipc_info.h                     |   11 +-
 .../mach_debug/mach_debug_types.h             |  200 +
 .../malloc/malloc.h                           |   37 +-
 .../net/if.h                                  |   42 +-
 .../uio.h => any-macos.13-any/net/if_dl.h}    |   82 +-
 .../net/if_var.h                              |   15 +-
 .../net/route.h                               |   15 +-
 .../netinet/in.h                              |   11 +-
 .../netinet/tcp.h                             |   17 +-
 .../netinet6/in6.h                            |   34 +-
 .../objc/NSObjCRuntime.h                      |    2 +-
 .../objc/message.h                            |   75 +-
 .../objc/objc-api.h                           |   66 +-
 lib/libc/include/any-macos.13-any/objc/objc.h |  236 +
 .../objc/runtime.h                            |  459 +-
 .../any-macos.13-any/os/availability.h        |  195 +
 .../os/base.h                                 |   77 +-
 lib/libc/include/any-macos.13-any/os/lock.h   |  202 +
 .../os/object.h                               |   49 +-
 .../any-macos.13-any/os/workgroup_base.h      |   85 +
 .../any-macos.13-any/os/workgroup_interval.h  |  157 +
 .../any-macos.13-any/os/workgroup_object.h    |  359 +
 .../any-macos.13-any/os/workgroup_parallel.h  |   76 +
 .../pthread.h                                 |  192 +-
 .../simd/base.h                               |   16 +-
 .../simd/math.h                               | 1071 ++-
 .../stdio.h                                   |   37 +-
 .../stdlib.h                                  |   26 +-
 .../sys/_symbol_aliasing.h                    |  138 +
 .../sys/_types/_graftdmg_un.h                 |   60 +
 .../sys/cdefs.h                               |  144 +-
 .../sys/clonefile.h}                          |   28 +-
 .../any-macos.13-any/sys/constrained_ctypes.h |  591 ++
 .../sys/event.h                               |   11 +-
 .../sys/fcntl.h                               |  163 +-
 .../ioctl.h => any-macos.13-any/sys/filio.h}  |   53 +-
 .../sys/mount.h                               |   28 +-
 .../sys/proc_info.h                           |   68 +-
 .../sys/resource.h                            |  122 +-
 .../sys/socket.h                              |   51 +-
 .../sys/spawn.h                               |    9 +-
 .../sys/stat.h                                |    6 +-
 .../sys/sysctl.h                              |   92 +-
 lib/libc/include/any-macos.13-any/sys/time.h  |  210 +
 lib/libc/include/any-macos.13-any/sys/types.h |  235 +
 .../include/any-macos.13-any/sys/unistd.h     |  220 +
 .../xpc/base.h                                |   35 +-
 .../xpc/connection.h                          |   61 +-
 .../include/any-macos.13-any/xpc/rich_error.h |   52 +
 .../include/any-macos.13-any/xpc/session.h    |  346 +
 .../xpc/xpc.h                                 |  102 +-
 .../x86_64-macos.10-none/AssertMacros.h       | 1441 ----
 .../x86_64-macos.10-none/TargetConditionals.h |  502 --
 .../include/x86_64-macos.10-none/_ctermid.h   |   27 -
 .../include/x86_64-macos.10-none/assert.h     |  111 -
 .../include/x86_64-macos.10-none/bsm/audit.h  |  378 -
 .../device/device_types.h                     |  118 -
 .../x86_64-macos.10-none/dispatch/dispatch.h  |   75 -
 .../include/x86_64-macos.10-none/execinfo.h   |   63 -
 .../libkern/OSByteOrder.h                     |  305 -
 .../libkern/_OSByteOrder.h                    |  130 -
 .../mach-o/compact_unwind_encoding.h          |  427 --
 .../x86_64-macos.10-none/mach-o/dyld.h        |  263 -
 .../x86_64-macos.10-none/mach/kern_return.h   |  330 -
 .../x86_64-macos.10-none/mach/lock_set.h      |  350 -
 .../x86_64-macos.10-none/mach/mach_init.h     |  110 -
 .../x86_64-macos.10-none/mach/mach_traps.h    |  303 -
 .../mach/machine/_structs.h                   |   38 -
 .../mach/machine/boolean.h                    |   38 -
 .../mach/machine/exception.h                  |   38 -
 .../mach/machine/kern_return.h                |   38 -
 .../mach/machine/processor_info.h             |   38 -
 .../mach/machine/thread_state.h               |   38 -
 .../mach/machine/thread_status.h              |   38 -
 .../mach/machine/vm_param.h                   |   38 -
 .../mach/machine/vm_types.h                   |   38 -
 .../mach/memory_object_types.h                |  299 -
 .../include/x86_64-macos.10-none/mach/mig.h   |  180 -
 .../x86_64-macos.10-none/mach/task_info.h     |  478 --
 .../x86_64-macos.10-none/mach/task_inspect.h  |   54 -
 .../mach/task_special_ports.h                 |  132 -
 .../x86_64-macos.10-none/mach/thread_state.h  |   63 -
 .../x86_64-macos.10-none/mach/thread_status.h |   97 -
 .../mach_debug/mach_debug_types.h             |   95 -
 .../x86_64-macos.10-none/machine/_mcontext.h  |   32 -
 .../x86_64-macos.10-none/machine/_param.h     |   32 -
 .../x86_64-macos.10-none/machine/_types.h     |   37 -
 .../x86_64-macos.10-none/machine/endian.h     |   40 -
 .../x86_64-macos.10-none/machine/limits.h     |    9 -
 .../x86_64-macos.10-none/machine/param.h      |   40 -
 .../x86_64-macos.10-none/machine/signal.h     |   37 -
 .../x86_64-macos.10-none/malloc/_malloc.h     |   56 -
 lib/libc/include/x86_64-macos.10-none/math.h  |  771 --
 .../x86_64-macos.10-none/net/net_kev.h        |   98 -
 .../x86_64-macos.10-none/pthread_impl.h       |   66 -
 lib/libc/include/x86_64-macos.10-none/sched.h |   43 -
 .../include/x86_64-macos.10-none/signal.h     |  129 -
 .../x86_64-macos.10-none/simd/common.h        | 4458 -----------
 .../x86_64-macos.10-none/simd/conversion.h    | 1876 -----
 .../include/x86_64-macos.10-none/simd/logic.h | 1315 ----
 .../x86_64-macos.10-none/simd/matrix.h        | 1786 -----
 .../x86_64-macos.10-none/simd/matrix_types.h  |  264 -
 .../x86_64-macos.10-none/simd/packed.h        | 1031 ---
 .../x86_64-macos.10-none/simd/quaternion.h    | 1192 ---
 .../x86_64-macos.10-none/simd/vector_make.h   | 6768 -----------------
 lib/libc/include/x86_64-macos.10-none/spawn.h |  165 -
 .../include/x86_64-macos.10-none/string.h     |  193 -
 .../sys/_pthread/_pthread_attr_t.h            |   32 -
 .../sys/_pthread/_pthread_cond_t.h            |   32 -
 .../sys/_pthread/_pthread_condattr_t.h        |   32 -
 .../sys/_pthread/_pthread_rwlock_t.h          |   32 -
 .../sys/_pthread/_pthread_rwlockattr_t.h      |   32 -
 .../sys/_pthread/_pthread_t.h                 |   32 -
 .../sys/_pthread/_pthread_types.h             |  120 -
 .../x86_64-macos.10-none/sys/_select.h        |   52 -
 .../x86_64-macos.10-none/sys/_types/_fd_def.h |  114 -
 .../x86_64-macos.10-none/sys/_types/_int8_t.h |   31 -
 .../sys/_types/_ucontext.h                    |   58 -
 .../sys/_types/_uintptr_t.h                   |   31 -
 .../include/x86_64-macos.10-none/sys/acl.h    |  211 -
 .../include/x86_64-macos.10-none/sys/attr.h   |  579 --
 .../include/x86_64-macos.10-none/sys/ioccom.h |   99 -
 .../include/x86_64-macos.10-none/sys/kauth.h  |  407 -
 .../include/x86_64-macos.10-none/sys/mman.h   |  250 -
 .../include/x86_64-macos.10-none/sys/param.h  |  253 -
 .../include/x86_64-macos.10-none/sys/proc.h   |  223 -
 .../include/x86_64-macos.10-none/sys/shm.h    |  186 -
 .../include/x86_64-macos.10-none/sys/sockio.h |  180 -
 .../x86_64-macos.10-none/sys/syslimits.h      |  117 -
 .../include/x86_64-macos.10-none/sys/ttycom.h |  173 -
 .../x86_64-macos.10-none/sys/ucontext.h       |   42 -
 .../include/x86_64-macos.10-none/sys/un.h     |  105 -
 lib/libc/include/x86_64-macos.10-none/time.h  |  208 -
 .../include/x86_64-macos.10-none/ucontext.h   |   46 -
 .../include/x86_64-macos.10-none/unistd.h     |  787 --
 .../include/x86_64-macos.10-none/uuid/uuid.h  |   79 -
 .../x86_64-macos.10-none/xlocale/_inttypes.h  |   47 -
 .../x86_64-macos.10-none/xlocale/_wchar.h     |  145 -
 .../x86_64-macos.10-none/xpc/activity.h       |  446 --
 .../x86_64-macos.10-none/xpc/availability.h   |  120 -
 .../i386/_limits.h                            |    4 +
 .../i386/_mcontext.h                          |    4 +
 .../i386/_param.h                             |    7 +-
 .../i386/_types.h                             |    4 +
 .../i386/eflags.h                             |    4 +
 .../i386/endian.h                             |    3 +
 .../i386/limits.h                             |    4 +
 .../i386/param.h                              |    4 +
 .../i386/signal.h                             |    4 +
 .../i386/types.h                              |    8 +-
 .../libkern/OSAtomic.h}                       |   44 +-
 .../libkern/OSAtomicDeprecated.h              | 1266 +++
 .../libkern/OSAtomicQueue.h                   |  115 +
 .../libkern/OSSpinLockDeprecated.h            |  212 +
 .../libkern/i386/OSByteOrder.h                |    0
 .../libkern/i386/_OSByteOrder.h               |    0
 .../mach/i386/_structs.h                      |   84 +
 .../mach/i386/boolean.h                       |    4 +
 .../mach/i386/exception.h                     |    4 +
 .../mach/i386/fp_reg.h                        |    4 +
 .../mach/i386/kern_return.h                   |    4 +
 .../mach/i386/processor_info.h                |    4 +
 .../mach/i386/rpc.h                           |    4 +
 .../mach/i386/thread_state.h                  |    8 +-
 .../mach/i386/thread_status.h                 |   25 +-
 .../mach/i386/vm_param.h                      |   63 +-
 .../mach/i386/vm_types.h                      |   18 +-
 252 files changed, 14060 insertions(+), 34202 deletions(-)
 create mode 100644 lib/libc/include/aarch64-macos.13-none/arm/_limits.h
 create mode 100644 lib/libc/include/aarch64-macos.13-none/arm/_mcontext.h
 create mode 100644 lib/libc/include/aarch64-macos.13-none/arm/_param.h
 create mode 100644 lib/libc/include/aarch64-macos.13-none/arm/_types.h
 rename lib/libc/include/{x86_64-macos.10-none/gethostuuid.h => aarch64-macos.13-none/arm/arch.h} (50%)
 create mode 100644 lib/libc/include/aarch64-macos.13-none/arm/endian.h
 create mode 100644 lib/libc/include/aarch64-macos.13-none/arm/limits.h
 create mode 100644 lib/libc/include/aarch64-macos.13-none/arm/param.h
 create mode 100644 lib/libc/include/aarch64-macos.13-none/arm/signal.h
 create mode 100644 lib/libc/include/aarch64-macos.13-none/arm/types.h
 rename lib/libc/include/{x86_64-macos.10-none => aarch64-macos.13-none}/libkern/OSAtomic.h (100%)
 rename lib/libc/include/{x86_64-macos.10-none => aarch64-macos.13-none}/libkern/OSAtomicDeprecated.h (93%)
 rename lib/libc/include/{x86_64-macos.10-none => aarch64-macos.13-none}/libkern/OSAtomicQueue.h (59%)
 rename lib/libc/include/{x86_64-macos.10-none => aarch64-macos.13-none}/libkern/OSSpinLockDeprecated.h (100%)
 create mode 100644 lib/libc/include/aarch64-macos.13-none/libkern/arm/OSByteOrder.h
 create mode 100644 lib/libc/include/aarch64-macos.13-none/mach/arm/_structs.h
 rename lib/libc/include/{x86_64-macos.10-none/mach/vm_param.h => aarch64-macos.13-none/mach/arm/boolean.h} (85%)
 create mode 100644 lib/libc/include/aarch64-macos.13-none/mach/arm/exception.h
 rename lib/libc/include/{x86_64-macos.10-none/mach/thread_special_ports.h => aarch64-macos.13-none/mach/arm/kern_return.h} (72%)
 create mode 100644 lib/libc/include/aarch64-macos.13-none/mach/arm/processor_info.h
 rename lib/libc/include/{x86_64-macos.10-none/mach/machine => aarch64-macos.13-none/mach/arm}/rpc.h (86%)
 rename lib/libc/include/{x86_64-macos.10-none/machine/types.h => aarch64-macos.13-none/mach/arm/thread_state.h} (78%)
 create mode 100644 lib/libc/include/aarch64-macos.13-none/mach/arm/thread_status.h
 create mode 100644 lib/libc/include/aarch64-macos.13-none/mach/arm/vm_param.h
 create mode 100644 lib/libc/include/aarch64-macos.13-none/mach/arm/vm_types.h
 rename lib/libc/include/{any-macos.12-any => any-macos-any}/TargetConditionals.h (100%)
 rename lib/libc/include/{any-macos.12-any => any-macos-any}/mach/mach_init.h (100%)
 rename lib/libc/include/{any-macos.12-any => any-macos-any}/mach/task_info.h (100%)
 rename lib/libc/include/{any-macos.12-any => any-macos-any}/spawn.h (100%)
 rename lib/libc/include/{any-macos.12-any => any-macos-any}/sys/attr.h (100%)
 rename lib/libc/include/{any-macos.12-any => any-macos-any}/time.h (100%)
 rename lib/libc/include/{any-macos-any => any-macos.11-any}/copyfile.h (100%)
 rename lib/libc/include/{any-macos.12-any => any-macos.11-any}/sys/stdio.h (91%)
 rename lib/libc/include/{any-macos-any => any-macos.11-any}/sys/unistd.h (100%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/Availability.h (77%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/AvailabilityInternal.h (99%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/AvailabilityMacros.h (99%)
 create mode 100644 lib/libc/include/any-macos.13-any/AvailabilityVersions.h
 create mode 100644 lib/libc/include/any-macos.13-any/Block.h
 create mode 100644 lib/libc/include/any-macos.13-any/copyfile.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/dispatch/base.h (86%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/dispatch/block.h (99%)
 create mode 100644 lib/libc/include/any-macos.13-any/dispatch/data.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/dispatch/group.h (99%)
 create mode 100644 lib/libc/include/any-macos.13-any/dispatch/io.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/dispatch/object.h (98%)
 create mode 100644 lib/libc/include/any-macos.13-any/dispatch/once.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/dispatch/queue.h (98%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/dispatch/semaphore.h (91%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/dispatch/source.h (99%)
 create mode 100644 lib/libc/include/any-macos.13-any/dispatch/time.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/dispatch/workloop.h (76%)
 create mode 100644 lib/libc/include/any-macos.13-any/dlfcn.h
 create mode 100644 lib/libc/include/any-macos.13-any/launch.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/libproc.h (79%)
 create mode 100644 lib/libc/include/any-macos.13-any/mach-o/arch.h
 create mode 100644 lib/libc/include/any-macos.13-any/mach-o/fat.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach-o/loader.h (96%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/clock.h (94%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/clock_priv.h (93%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/exception_types.h (92%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/host_priv.h (98%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/host_security.h (94%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/host_special_ports.h (91%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/mach.h (99%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/mach_host.h (97%)
 rename lib/libc/include/{x86_64-macos.10-none/mach/sync_policy.h => any-macos.13-any/mach/mach_interface.h} (63%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/mach_port.h (91%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/mach_types.h (82%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/mach_voucher_types.h (97%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/machine.h (94%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/message.h (94%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/port.h (80%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/processor.h (96%)
 create mode 100644 lib/libc/include/any-macos.13-any/mach/processor_info.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/processor_set.h (89%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/task.h (83%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/task_policy.h (99%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/thread_act.h (89%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/thread_policy.h (95%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/vm_map.h (93%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/vm_prot.h (82%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/vm_statistics.h (87%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach/vm_types.h (82%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/mach_debug/ipc_info.h (94%)
 create mode 100644 lib/libc/include/any-macos.13-any/mach_debug/mach_debug_types.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/malloc/malloc.h (92%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/net/if.h (95%)
 rename lib/libc/include/{x86_64-macos.10-none/sys/uio.h => any-macos.13-any/net/if_dl.h} (59%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/net/if_var.h (96%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/net/route.h (96%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/netinet/in.h (99%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/netinet/tcp.h (96%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/netinet6/in6.h (96%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/objc/NSObjCRuntime.h (94%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/objc/message.h (83%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/objc/objc-api.h (86%)
 create mode 100644 lib/libc/include/any-macos.13-any/objc/objc.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/objc/runtime.h (85%)
 create mode 100644 lib/libc/include/any-macos.13-any/os/availability.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/os/base.h (82%)
 create mode 100644 lib/libc/include/any-macos.13-any/os/lock.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/os/object.h (82%)
 create mode 100644 lib/libc/include/any-macos.13-any/os/workgroup_base.h
 create mode 100644 lib/libc/include/any-macos.13-any/os/workgroup_interval.h
 create mode 100644 lib/libc/include/any-macos.13-any/os/workgroup_object.h
 create mode 100644 lib/libc/include/any-macos.13-any/os/workgroup_parallel.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/pthread.h (66%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/simd/base.h (84%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/simd/math.h (81%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/stdio.h (92%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/stdlib.h (94%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/sys/_symbol_aliasing.h (78%)
 create mode 100644 lib/libc/include/any-macos.13-any/sys/_types/_graftdmg_un.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/sys/cdefs.h (86%)
 rename lib/libc/include/{x86_64-macos.10-none/sys/random.h => any-macos.13-any/sys/clonefile.h} (57%)
 create mode 100644 lib/libc/include/any-macos.13-any/sys/constrained_ctypes.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/sys/event.h (98%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/sys/fcntl.h (81%)
 rename lib/libc/include/{x86_64-macos.10-none/sys/ioctl.h => any-macos.13-any/sys/filio.h} (78%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/sys/mount.h (95%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/sys/proc_info.h (94%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/sys/resource.h (81%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/sys/socket.h (95%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/sys/spawn.h (91%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/sys/stat.h (98%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/sys/sysctl.h (89%)
 create mode 100644 lib/libc/include/any-macos.13-any/sys/time.h
 create mode 100644 lib/libc/include/any-macos.13-any/sys/types.h
 create mode 100644 lib/libc/include/any-macos.13-any/sys/unistd.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/xpc/base.h (83%)
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/xpc/connection.h (92%)
 create mode 100644 lib/libc/include/any-macos.13-any/xpc/rich_error.h
 create mode 100644 lib/libc/include/any-macos.13-any/xpc/session.h
 rename lib/libc/include/{x86_64-macos.10-none => any-macos.13-any}/xpc/xpc.h (96%)
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/AssertMacros.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/TargetConditionals.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/_ctermid.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/assert.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/bsm/audit.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/device/device_types.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/dispatch/dispatch.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/execinfo.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/libkern/OSByteOrder.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/libkern/_OSByteOrder.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach-o/compact_unwind_encoding.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach-o/dyld.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/kern_return.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/lock_set.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/mach_init.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/mach_traps.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/machine/_structs.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/machine/boolean.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/machine/exception.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/machine/kern_return.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/machine/processor_info.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/machine/thread_state.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/machine/thread_status.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/machine/vm_param.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/machine/vm_types.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/memory_object_types.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/mig.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/task_info.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/task_inspect.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/task_special_ports.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/thread_state.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach/thread_status.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/mach_debug/mach_debug_types.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/machine/_mcontext.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/machine/_param.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/machine/_types.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/machine/endian.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/machine/limits.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/machine/param.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/machine/signal.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/malloc/_malloc.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/math.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/net/net_kev.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/pthread_impl.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sched.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/signal.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/simd/common.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/simd/conversion.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/simd/logic.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/simd/matrix.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/simd/matrix_types.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/simd/packed.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/simd/quaternion.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/simd/vector_make.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/spawn.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/string.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_attr_t.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_cond_t.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_condattr_t.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_rwlock_t.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_rwlockattr_t.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_t.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_types.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/_select.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/_types/_fd_def.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/_types/_int8_t.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/_types/_ucontext.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/_types/_uintptr_t.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/acl.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/attr.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/ioccom.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/kauth.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/mman.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/param.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/proc.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/shm.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/sockio.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/syslimits.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/ttycom.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/ucontext.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/sys/un.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/time.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/ucontext.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/unistd.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/uuid/uuid.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/xlocale/_inttypes.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/xlocale/_wchar.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/xpc/activity.h
 delete mode 100644 lib/libc/include/x86_64-macos.10-none/xpc/availability.h
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/i386/_limits.h (91%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/i386/_mcontext.h (98%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/i386/_param.h (83%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/i386/_types.h (97%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/i386/eflags.h (97%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/i386/endian.h (97%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/i386/limits.h (97%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/i386/param.h (98%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/i386/signal.h (93%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/i386/types.h (96%)
 rename lib/libc/include/{x86_64-macos.10-none/pthread/sched.h => x86_64-macos.13-none/libkern/OSAtomic.h} (56%)
 create mode 100644 lib/libc/include/x86_64-macos.13-none/libkern/OSAtomicDeprecated.h
 create mode 100644 lib/libc/include/x86_64-macos.13-none/libkern/OSAtomicQueue.h
 create mode 100644 lib/libc/include/x86_64-macos.13-none/libkern/OSSpinLockDeprecated.h
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/libkern/i386/OSByteOrder.h (100%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/libkern/i386/_OSByteOrder.h (100%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/mach/i386/_structs.h (94%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/mach/i386/boolean.h (96%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/mach/i386/exception.h (97%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/mach/i386/fp_reg.h (98%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/mach/i386/kern_return.h (96%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/mach/i386/processor_info.h (93%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/mach/i386/rpc.h (93%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/mach/i386/thread_state.h (90%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/mach/i386/thread_status.h (93%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/mach/i386/vm_param.h (80%)
 rename lib/libc/include/{x86_64-macos.10-none => x86_64-macos.13-none}/mach/i386/vm_types.h (89%)

diff --git a/lib/libc/include/aarch64-macos.13-none/arm/_limits.h b/lib/libc/include/aarch64-macos.13-none/arm/_limits.h
new file mode 100644
index 0000000000..8cb2759402
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/arm/_limits.h
@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2004-2007 Apple Inc. All rights reserved.
+ */
+#ifndef _ARM__LIMITS_H_
+#define _ARM__LIMITS_H_
+
+#if defined (__arm__) || defined (__arm64__)
+
+#define __DARWIN_CLK_TCK                100     /* ticks per second */
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif  /* _ARM__LIMITS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-macos.13-none/arm/_mcontext.h b/lib/libc/include/aarch64-macos.13-none/arm/_mcontext.h
new file mode 100644
index 0000000000..26b83ce221
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/arm/_mcontext.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+
+#ifndef __ARM_MCONTEXT_H_
+#define __ARM_MCONTEXT_H_
+
+#if defined (__arm__) || defined (__arm64__)
+
+#include <sys/cdefs.h> /* __DARWIN_UNIX03 */
+#include <sys/appleapiopts.h>
+#include <mach/machine/_structs.h>
+
+#ifndef _STRUCT_MCONTEXT32
+#if __DARWIN_UNIX03
+#define _STRUCT_MCONTEXT32        struct __darwin_mcontext32
+_STRUCT_MCONTEXT32
+{
+	_STRUCT_ARM_EXCEPTION_STATE     __es;
+	_STRUCT_ARM_THREAD_STATE        __ss;
+	_STRUCT_ARM_VFP_STATE           __fs;
+};
+
+#else /* !__DARWIN_UNIX03 */
+#define _STRUCT_MCONTEXT32        struct mcontext32
+_STRUCT_MCONTEXT32
+{
+	_STRUCT_ARM_EXCEPTION_STATE     es;
+	_STRUCT_ARM_THREAD_STATE        ss;
+	_STRUCT_ARM_VFP_STATE           fs;
+};
+
+#endif /* __DARWIN_UNIX03 */
+#endif /* _STRUCT_MCONTEXT32 */
+
+
+#ifndef _STRUCT_MCONTEXT64
+#if __DARWIN_UNIX03
+#define _STRUCT_MCONTEXT64      struct __darwin_mcontext64
+_STRUCT_MCONTEXT64
+{
+	_STRUCT_ARM_EXCEPTION_STATE64   __es;
+	_STRUCT_ARM_THREAD_STATE64      __ss;
+	_STRUCT_ARM_NEON_STATE64        __ns;
+};
+
+#else /* !__DARWIN_UNIX03 */
+#define _STRUCT_MCONTEXT64      struct mcontext64
+_STRUCT_MCONTEXT64
+{
+	_STRUCT_ARM_EXCEPTION_STATE64   es;
+	_STRUCT_ARM_THREAD_STATE64      ss;
+	_STRUCT_ARM_NEON_STATE64        ns;
+};
+#endif /* __DARWIN_UNIX03 */
+#endif /* _STRUCT_MCONTEXT32 */
+
+#ifndef _MCONTEXT_T
+#define _MCONTEXT_T
+#if defined(__arm64__)
+typedef _STRUCT_MCONTEXT64      *mcontext_t;
+#define _STRUCT_MCONTEXT _STRUCT_MCONTEXT64
+#else
+typedef _STRUCT_MCONTEXT32      *mcontext_t;
+#define _STRUCT_MCONTEXT        _STRUCT_MCONTEXT32
+#endif
+#endif /* _MCONTEXT_T */
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif /* __ARM_MCONTEXT_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-macos.13-none/arm/_param.h b/lib/libc/include/aarch64-macos.13-none/arm/_param.h
new file mode 100644
index 0000000000..10b9edf2f3
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/arm/_param.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2006-2007 Apple Inc. All rights reserved.
+ */
+
+#ifndef _ARM__PARAM_H_
+#define _ARM__PARAM_H_
+
+#if defined (__arm__) || defined (__arm64__)
+
+#include <arm/_types.h>
+
+/*
+ * Round p (pointer or byte index) up to a correctly-aligned value for all
+ * data types (int, long, ...).   The result is unsigned int and must be
+ * cast to any desired pointer type.
+ */
+#define __DARWIN_ALIGNBYTES     (sizeof(__darwin_size_t) - 1)
+#define __DARWIN_ALIGN(p)       ((__darwin_size_t)((__darwin_size_t)(p) + __DARWIN_ALIGNBYTES) &~ __DARWIN_ALIGNBYTES)
+
+#define      __DARWIN_ALIGNBYTES32     (sizeof(__uint32_t) - 1)
+#define       __DARWIN_ALIGN32(p)       ((__darwin_size_t)((__darwin_size_t)(p) + __DARWIN_ALIGNBYTES32) &~ __DARWIN_ALIGNBYTES32)
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif /* _ARM__PARAM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-macos.13-none/arm/_types.h b/lib/libc/include/aarch64-macos.13-none/arm/_types.h
new file mode 100644
index 0000000000..403ec44048
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/arm/_types.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
+ */
+#ifndef _BSD_ARM__TYPES_H_
+#define _BSD_ARM__TYPES_H_
+
+#if defined (__arm__) || defined (__arm64__)
+
+/*
+ * This header file contains integer types.  It's intended to also contain
+ * flotaing point and other arithmetic types, as needed, later.
+ */
+
+#ifdef __GNUC__
+typedef __signed char           __int8_t;
+#else   /* !__GNUC__ */
+typedef char                    __int8_t;
+#endif  /* !__GNUC__ */
+typedef unsigned char           __uint8_t;
+typedef short                   __int16_t;
+typedef unsigned short          __uint16_t;
+typedef int                     __int32_t;
+typedef unsigned int            __uint32_t;
+typedef long long               __int64_t;
+typedef unsigned long long      __uint64_t;
+
+typedef long                    __darwin_intptr_t;
+typedef unsigned int            __darwin_natural_t;
+
+/*
+ * The rune type below is declared to be an ``int'' instead of the more natural
+ * ``unsigned long'' or ``long''.  Two things are happening here.  It is not
+ * unsigned so that EOF (-1) can be naturally assigned to it and used.  Also,
+ * it looks like 10646 will be a 31 bit standard.  This means that if your
+ * ints cannot hold 32 bits, you will be in trouble.  The reason an int was
+ * chosen over a long is that the is*() and to*() routines take ints (says
+ * ANSI C), but they use __darwin_ct_rune_t instead of int.  By changing it
+ * here, you lose a bit of ANSI conformance, but your programs will still
+ * work.
+ *
+ * NOTE: rune_t is not covered by ANSI nor other standards, and should not
+ * be instantiated outside of lib/libc/locale.  Use wchar_t.  wchar_t and
+ * rune_t must be the same type.  Also wint_t must be no narrower than
+ * wchar_t, and should also be able to hold all members of the largest
+ * character set plus one extra value (WEOF). wint_t must be at least 16 bits.
+ */
+
+typedef int                     __darwin_ct_rune_t;     /* ct_rune_t */
+
+/*
+ * mbstate_t is an opaque object to keep conversion state, during multibyte
+ * stream conversions.  The content must not be referenced by user programs.
+ */
+typedef union {
+	char            __mbstate8[128];
+	long long       _mbstateL;                      /* for alignment */
+} __mbstate_t;
+
+typedef __mbstate_t             __darwin_mbstate_t;     /* mbstate_t */
+
+#if defined(__PTRDIFF_TYPE__)
+typedef __PTRDIFF_TYPE__        __darwin_ptrdiff_t;     /* ptr1 - ptr2 */
+#elif defined(__LP64__)
+typedef long                    __darwin_ptrdiff_t;     /* ptr1 - ptr2 */
+#else
+typedef int                     __darwin_ptrdiff_t;     /* ptr1 - ptr2 */
+#endif /* __GNUC__ */
+
+#if defined(__SIZE_TYPE__)
+typedef __SIZE_TYPE__           __darwin_size_t;        /* sizeof() */
+#else
+typedef unsigned long           __darwin_size_t;        /* sizeof() */
+#endif
+
+#if (__GNUC__ > 2)
+typedef __builtin_va_list       __darwin_va_list;       /* va_list */
+#else
+typedef void *                  __darwin_va_list;       /* va_list */
+#endif
+
+#if defined(__WCHAR_TYPE__)
+typedef __WCHAR_TYPE__          __darwin_wchar_t;       /* wchar_t */
+#else
+typedef __darwin_ct_rune_t      __darwin_wchar_t;       /* wchar_t */
+#endif
+
+typedef __darwin_wchar_t        __darwin_rune_t;        /* rune_t */
+
+#if defined(__WINT_TYPE__)
+typedef __WINT_TYPE__           __darwin_wint_t;        /* wint_t */
+#else
+typedef __darwin_ct_rune_t      __darwin_wint_t;        /* wint_t */
+#endif
+
+typedef unsigned long           __darwin_clock_t;       /* clock() */
+typedef __uint32_t              __darwin_socklen_t;     /* socklen_t (duh) */
+typedef long                    __darwin_ssize_t;       /* byte count or error */
+typedef long                    __darwin_time_t;        /* time() */
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif  /* _BSD_ARM__TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/gethostuuid.h b/lib/libc/include/aarch64-macos.13-none/arm/arch.h
similarity index 50%
rename from lib/libc/include/x86_64-macos.10-none/gethostuuid.h
rename to lib/libc/include/aarch64-macos.13-none/arm/arch.h
index cc7f473118..b8b25e55d3 100644
--- a/lib/libc/include/x86_64-macos.10-none/gethostuuid.h
+++ b/lib/libc/include/aarch64-macos.13-none/arm/arch.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013 Apple Inc. All rights reserved.
+ * Copyright (c) 2007 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -25,18 +25,47 @@
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
+#ifndef _ARM_ARCH_H
+#define _ARM_ARCH_H
 
-#ifndef __GETHOSTUUID_H
-#define __GETHOSTUUID_H
+#if defined (__arm__) || defined (__arm64__)
 
-#include <sys/_types/_timespec.h>
-#include <sys/_types/_uuid_t.h>
-#include <Availability.h>
-
-#if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && (__IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_0)
-int gethostuuid(uuid_t, const struct timespec *) __OSX_AVAILABLE_BUT_DEPRECATED_MSG(__MAC_NA, __MAC_NA, __IPHONE_2_0, __IPHONE_5_0, "gethostuuid() is no longer supported");
-#else
-int gethostuuid(uuid_t, const struct timespec *) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_NA);
+/* Collect the __ARM_ARCH_*__ compiler flags into something easier to use. */
+#if defined (__ARM_ARCH_7A__) || defined (__ARM_ARCH_7S__) || defined (__ARM_ARCH_7F__) || defined (__ARM_ARCH_7K__)
+#define _ARM_ARCH_7
 #endif
 
-#endif /* __GETHOSTUUID_H */
\ No newline at end of file
+#if defined (_ARM_ARCH_7) || defined (__ARM_ARCH_6K__) || defined (__ARM_ARCH_6ZK__)
+#define _ARM_ARCH_6K
+#endif
+
+#if defined (_ARM_ARCH_7) || defined (__ARM_ARCH_6Z__) || defined (__ARM_ARCH_6ZK__)
+#define _ARM_ARCH_6Z
+#endif
+
+#if defined (__ARM_ARCH_6__) || defined (__ARM_ARCH_6J__) || \
+        defined (_ARM_ARCH_6Z) || defined (_ARM_ARCH_6K)
+#define _ARM_ARCH_6
+#endif
+
+#if defined (_ARM_ARCH_6) || defined (__ARM_ARCH_5E__) || \
+        defined (__ARM_ARCH_5TE__) || defined (__ARM_ARCH_5TEJ__)
+#define _ARM_ARCH_5E
+#endif
+
+#if defined (_ARM_ARCH_5E) || defined (__ARM_ARCH_5__) || \
+        defined (__ARM_ARCH_5T__)
+#define _ARM_ARCH_5
+#endif
+
+#if defined (_ARM_ARCH_5) || defined (__ARM_ARCH_4T__)
+#define _ARM_ARCH_4T
+#endif
+
+#if defined (_ARM_ARCH_4T) || defined (__ARM_ARCH_4__)
+#define _ARM_ARCH_4
+#endif
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-macos.13-none/arm/endian.h b/lib/libc/include/aarch64-macos.13-none/arm/endian.h
new file mode 100644
index 0000000000..851f2eafe2
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/arm/endian.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
+ */
+/*
+ * Copyright 1995 NeXT Computer, Inc. All rights reserved.
+ */
+/*
+ * Copyright (c) 1987, 1991, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)endian.h	8.1 (Berkeley) 6/11/93
+ */
+
+#ifndef _ARM__ENDIAN_H_
+#define _ARM__ENDIAN_H_
+
+#if defined (__arm__) || defined (__arm64__)
+
+#include <sys/cdefs.h>
+/*
+ * Define _NOQUAD if the compiler does NOT support 64-bit integers.
+ */
+/* #define _NOQUAD */
+
+/*
+ * Define the order of 32-bit words in 64-bit words.
+ */
+#define _QUAD_HIGHWORD 1
+#define _QUAD_LOWWORD 0
+
+/*
+ * Definitions for byte order, according to byte significance from low
+ * address to high.
+ */
+#define __DARWIN_LITTLE_ENDIAN  1234    /* LSB first: i386, vax */
+#define __DARWIN_BIG_ENDIAN     4321    /* MSB first: 68000, ibm, net */
+#define __DARWIN_PDP_ENDIAN     3412    /* LSB first in word, MSW first in long */
+
+#define __DARWIN_BYTE_ORDER     __DARWIN_LITTLE_ENDIAN
+
+#if     defined(KERNEL) || (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
+
+#define LITTLE_ENDIAN   __DARWIN_LITTLE_ENDIAN
+#define BIG_ENDIAN      __DARWIN_BIG_ENDIAN
+#define PDP_ENDIAN      __DARWIN_PDP_ENDIAN
+
+#define BYTE_ORDER      __DARWIN_BYTE_ORDER
+
+#include <sys/_endian.h>
+
+#endif /* defined(KERNEL) || (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)) */
+#endif /* defined (__arm__) || defined (__arm64__) */
+#endif /* !_ARM__ENDIAN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-macos.13-none/arm/limits.h b/lib/libc/include/aarch64-macos.13-none/arm/limits.h
new file mode 100644
index 0000000000..21de9a758b
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/arm/limits.h
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
+ */
+/*
+ * Copyright (c) 1988, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)limits.h	8.3 (Berkeley) 1/4/94
+ */
+
+#ifndef _ARM_LIMITS_H_
+#define _ARM_LIMITS_H_
+
+#if defined (__arm__) || defined (__arm64__)
+
+#include <sys/cdefs.h>
+#include <arm/_limits.h>
+
+#define CHAR_BIT        8               /* number of bits in a char */
+#define MB_LEN_MAX      6               /* Allow 31 bit UTF2 */
+
+#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
+#define CLK_TCK         __DARWIN_CLK_TCK        /* ticks per second */
+#endif /* !_ANSI_SOURCE && (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
+
+/*
+ * According to ANSI (section 2.2.4.2), the values below must be usable by
+ * #if preprocessing directives.  Additionally, the expression must have the
+ * same type as would an expression that is an object of the corresponding
+ * type converted according to the integral promotions.  The subtraction for
+ * INT_MIN and LONG_MIN is so the value is not unsigned; 2147483648 is an
+ * unsigned int for 32-bit two's complement ANSI compilers (section 3.1.3.2).
+ * These numbers work for pcc as well.  The UINT_MAX and ULONG_MAX values
+ * are written as hex so that GCC will be quiet about large integer constants.
+ */
+#define SCHAR_MAX       127             /* min value for a signed char */
+#define SCHAR_MIN       (-128)          /* max value for a signed char */
+
+#define UCHAR_MAX       255             /* max value for an unsigned char */
+#define CHAR_MAX        127             /* max value for a char */
+#define CHAR_MIN        (-128)          /* min value for a char */
+
+#define USHRT_MAX       65535           /* max value for an unsigned short */
+#define SHRT_MAX        32767           /* max value for a short */
+#define SHRT_MIN        (-32768)        /* min value for a short */
+
+#define UINT_MAX        0xffffffff      /* max value for an unsigned int */
+#define INT_MAX         2147483647      /* max value for an int */
+#define INT_MIN         (-2147483647-1) /* min value for an int */
+
+#ifdef __LP64__
+#define ULONG_MAX       0xffffffffffffffffUL    /* max unsigned long */
+#define LONG_MAX        0x7fffffffffffffffL     /* max signed long */
+#define LONG_MIN        (-0x7fffffffffffffffL-1) /* min signed long */
+#else /* !__LP64__ */
+#define ULONG_MAX       0xffffffffUL    /* max unsigned long */
+#define LONG_MAX        2147483647L     /* max signed long */
+#define LONG_MIN        (-2147483647L-1) /* min signed long */
+#endif /* __LP64__ */
+
+#define ULLONG_MAX      0xffffffffffffffffULL   /* max unsigned long long */
+#define LLONG_MAX       0x7fffffffffffffffLL    /* max signed long long */
+#define LLONG_MIN       (-0x7fffffffffffffffLL-1) /* min signed long long */
+
+#if !defined(_ANSI_SOURCE)
+#ifdef __LP64__
+#define LONG_BIT        64
+#else /* !__LP64__ */
+#define LONG_BIT        32
+#endif /* __LP64__ */
+#define SSIZE_MAX       LONG_MAX        /* max value for a ssize_t */
+#define WORD_BIT        32
+
+#if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || defined(_DARWIN_C_SOURCE)
+#define SIZE_T_MAX      ULONG_MAX       /* max value for a size_t */
+
+#define UQUAD_MAX       ULLONG_MAX
+#define QUAD_MAX        LLONG_MAX
+#define QUAD_MIN        LLONG_MIN
+
+#endif /* (!_POSIX_C_SOURCE && !_XOPEN_SOURCE) || _DARWIN_C_SOURCE */
+#endif /* !_ANSI_SOURCE */
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif /* _ARM_LIMITS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-macos.13-none/arm/param.h b/lib/libc/include/aarch64-macos.13-none/arm/param.h
new file mode 100644
index 0000000000..f36fa322cb
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/arm/param.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2000-2010 Apple Inc. All rights reserved.
+ */
+/*-
+ * Copyright (c) 1990, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)param.h	8.1 (Berkeley) 4/4/95
+ */
+
+/*
+ * Machine dependent constants for ARM
+ */
+
+#ifndef _ARM_PARAM_H_
+#define _ARM_PARAM_H_
+
+#if defined (__arm__) || defined (__arm64__)
+
+#include <arm/_param.h>
+
+/*
+ * Round p (pointer or byte index) up to a correctly-aligned value for all
+ * data types (int, long, ...).   The result is unsigned int and must be
+ * cast to any desired pointer type.
+ */
+#define ALIGNBYTES      __DARWIN_ALIGNBYTES
+#define ALIGN(p)        __DARWIN_ALIGN(p)
+
+#define NBPG            4096            /* bytes/page */
+#define PGOFSET         (NBPG-1)        /* byte offset into page */
+#define PGSHIFT         12              /* LOG2(NBPG) */
+
+#define DEV_BSIZE       512
+#define DEV_BSHIFT      9               /* log2(DEV_BSIZE) */
+#define BLKDEV_IOSIZE   2048
+#define MAXPHYS         (64 * 1024)     /* max raw I/O transfer size */
+
+#define CLSIZE          1
+#define CLSIZELOG2      0
+
+/*
+ * Constants related to network buffer management.
+ * MCLBYTES must be no larger than CLBYTES (the software page size), and,
+ * on machines that exchange pages of input or output buffers with mbuf
+ * clusters (MAPPED_MBUFS), MCLBYTES must also be an integral multiple
+ * of the hardware page size.
+ */
+#define MSIZESHIFT      8                       /* 256 */
+#define MSIZE           (1 << MSIZESHIFT)       /* size of an mbuf */
+#define MCLSHIFT        11                      /* 2048 */
+#define MCLBYTES        (1 << MCLSHIFT)         /* size of an mbuf cluster */
+#define MBIGCLSHIFT     12                      /* 4096 */
+#define MBIGCLBYTES     (1 << MBIGCLSHIFT)      /* size of a big cluster */
+#define M16KCLSHIFT     14                      /* 16384 */
+#define M16KCLBYTES     (1 << M16KCLSHIFT)      /* size of a jumbo cluster */
+
+#define MCLOFSET        (MCLBYTES - 1)
+#ifndef NMBCLUSTERS
+#define NMBCLUSTERS     CONFIG_NMBCLUSTERS      /* cl map size */
+#endif
+
+/*
+ * Some macros for units conversion
+ */
+/* Core clicks (NeXT_page_size bytes) to segments and vice versa */
+#define ctos(x) (x)
+#define stoc(x) (x)
+
+/* Core clicks (4096 bytes) to disk blocks */
+#define ctod(x) ((x)<<(PGSHIFT-DEV_BSHIFT))
+#define dtoc(x) ((x)>>(PGSHIFT-DEV_BSHIFT))
+#define dtob(x) ((x)<<DEV_BSHIFT)
+
+/* clicks to bytes */
+#define ctob(x) ((x)<<PGSHIFT)
+
+/* bytes to clicks */
+#define btoc(x) (((unsigned)(x)+(NBPG-1))>>PGSHIFT)
+
+#ifdef __APPLE__
+#define  btodb(bytes, devBlockSize)         \
+	((unsigned)(bytes) / devBlockSize)
+#define  dbtob(db, devBlockSize)            \
+	((unsigned)(db) * devBlockSize)
+#else
+#define btodb(bytes)                    /* calculates (bytes / DEV_BSIZE) */ \
+	((unsigned)(bytes) >> DEV_BSHIFT)
+#define dbtob(db)                       /* calculates (db * DEV_BSIZE) */ \
+	((unsigned)(db) << DEV_BSHIFT)
+#endif
+
+/*
+ * Map a ``block device block'' to a file system block.
+ * This should be device dependent, and will be if we
+ * add an entry to cdevsw/bdevsw for that purpose.
+ * For now though just use DEV_BSIZE.
+ */
+#define bdbtofsb(bn)    ((bn) / (BLKDEV_IOSIZE/DEV_BSIZE))
+
+/*
+ * Macros to decode (and encode) processor status word.
+ */
+#define STATUS_WORD(rpl, ipl)   (((ipl) << 8) | (rpl))
+#define USERMODE(x)             (((x) & 3) == 3)
+#define BASEPRI(x)              (((x) & (255 << 8)) == 0)
+
+
+#if     defined(KERNEL) || defined(STANDALONE)
+#define DELAY(n) delay(n)
+
+#else   /* defined(KERNEL) || defined(STANDALONE) */
+#define DELAY(n)        { int N = (n); while (--N > 0); }
+#endif  /* defined(KERNEL) || defined(STANDALONE) */
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif /* _ARM_PARAM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-macos.13-none/arm/signal.h b/lib/libc/include/aarch64-macos.13-none/arm/signal.h
new file mode 100644
index 0000000000..4a8b96b383
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/arm/signal.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2000-2009 Apple, Inc. All rights reserved.
+ */
+/*
+ * Copyright (c) 1992 NeXT Computer, Inc.
+ *
+ */
+
+#ifndef _ARM_SIGNAL_
+#define _ARM_SIGNAL_ 1
+
+#if defined (__arm__) || defined (__arm64__)
+
+#include <sys/cdefs.h>
+
+#ifndef _ANSI_SOURCE
+typedef int sig_atomic_t;
+#endif /* ! _ANSI_SOURCE */
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif  /* _ARM_SIGNAL_ */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-macos.13-none/arm/types.h b/lib/libc/include/aarch64-macos.13-none/arm/types.h
new file mode 100644
index 0000000000..6cc1f453c9
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/arm/types.h
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2000-2008 Apple Inc. All rights reserved.
+ */
+/*
+ * Copyright 1995 NeXT Computer, Inc. All rights reserved.
+ */
+/*
+ * Copyright (c) 1990, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)types.h	8.3 (Berkeley) 1/5/94
+ */
+
+#ifndef _ARM_MACHTYPES_H_
+#define _ARM_MACHTYPES_H_
+#define _MACHTYPES_H_
+
+#if defined (__arm__) || defined (__arm64__)
+
+#ifndef __ASSEMBLER__
+#include <arm/_types.h>
+#include <sys/cdefs.h>
+/*
+ * Basic integral types.  Omit the typedef if
+ * not possible for a machine/compiler combination.
+ */
+#include <sys/_types/_int8_t.h>
+#include <sys/_types/_int16_t.h>
+#include <sys/_types/_int32_t.h>
+#include <sys/_types/_int64_t.h>
+
+#include <sys/_types/_u_int8_t.h>
+#include <sys/_types/_u_int16_t.h>
+#include <sys/_types/_u_int32_t.h>
+#include <sys/_types/_u_int64_t.h>
+
+#if __LP64__
+typedef int64_t                 register_t;
+#else
+typedef int32_t                 register_t;
+#endif
+
+#include <sys/_types/_intptr_t.h>
+#include <sys/_types/_uintptr_t.h>
+
+#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
+/* These types are used for reserving the largest possible size. */
+#ifdef __arm64__
+typedef u_int64_t               user_addr_t;
+typedef u_int64_t               user_size_t;
+typedef int64_t                 user_ssize_t;
+typedef int64_t                 user_long_t;
+typedef u_int64_t               user_ulong_t;
+typedef int64_t                 user_time_t;
+typedef int64_t                 user_off_t;
+#else
+typedef u_int32_t               user_addr_t;
+typedef u_int32_t               user_size_t;
+typedef int32_t                 user_ssize_t;
+typedef int32_t                 user_long_t;
+typedef u_int32_t               user_ulong_t;
+typedef int32_t                 user_time_t;
+typedef int64_t                 user_off_t;
+#endif
+
+#define USER_ADDR_NULL  ((user_addr_t) 0)
+#define CAST_USER_ADDR_T(a_ptr)   ((user_addr_t)((uintptr_t)(a_ptr)))
+
+
+#endif /* !_ANSI_SOURCE && (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
+
+/* This defines the size of syscall arguments after copying into the kernel: */
+#if defined(__arm__)
+typedef u_int32_t               syscall_arg_t;
+#elif defined(__arm64__)
+typedef u_int64_t               syscall_arg_t;
+#else
+#error Unknown architecture.
+#endif
+
+#endif /* __ASSEMBLER__ */
+#endif /* defined (__arm__) || defined (__arm64__) */
+#endif  /* _ARM_MACHTYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/libkern/OSAtomic.h b/lib/libc/include/aarch64-macos.13-none/libkern/OSAtomic.h
similarity index 100%
rename from lib/libc/include/x86_64-macos.10-none/libkern/OSAtomic.h
rename to lib/libc/include/aarch64-macos.13-none/libkern/OSAtomic.h
diff --git a/lib/libc/include/x86_64-macos.10-none/libkern/OSAtomicDeprecated.h b/lib/libc/include/aarch64-macos.13-none/libkern/OSAtomicDeprecated.h
similarity index 93%
rename from lib/libc/include/x86_64-macos.10-none/libkern/OSAtomicDeprecated.h
rename to lib/libc/include/aarch64-macos.13-none/libkern/OSAtomicDeprecated.h
index aef009bc04..6dc880b0d4 100644
--- a/lib/libc/include/x86_64-macos.10-none/libkern/OSAtomicDeprecated.h
+++ b/lib/libc/include/aarch64-macos.13-none/libkern/OSAtomicDeprecated.h
@@ -35,13 +35,14 @@
  * is preferred.
  */
 
+#include    <Availability.h>
+
 #if !(defined(OSATOMIC_USE_INLINED) && OSATOMIC_USE_INLINED)
 
 #include    <sys/cdefs.h>
 #include    <stddef.h>
 #include    <stdint.h>
 #include    <stdbool.h>
-#include    <Availability.h>
 
 #ifndef OSATOMIC_DEPRECATED
 #define OSATOMIC_DEPRECATED 1
@@ -161,7 +162,7 @@ __OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
 int32_t	OSAtomicAdd32Barrier( int32_t __theAmount, volatile int32_t *__theValue );
 
 
-#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_10 || __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_1
+#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_10 || __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_1 || TARGET_OS_DRIVERKIT
 
 /*! @abstract Atomically increments a 32-bit value.
     @result Returns the new value.
@@ -248,7 +249,7 @@ int64_t	OSAtomicAdd64Barrier( int64_t __theAmount,
 		volatile OSAtomic_int64_aligned64_t *__theValue );
 
 
-#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_10 || __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_1
+#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_10 || __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_1 || TARGET_OS_DRIVERKIT
 
 /*! @abstract Atomically increments a 64-bit value.
     @result Returns the new value.
@@ -361,7 +362,7 @@ int32_t	OSAtomicOr32Orig( uint32_t __theMask, volatile uint32_t *__theValue );
 	This function performs the bitwise OR of the value given by <code>__theMask</code>
 	with the value in the memory location referenced by <code>__theValue</code>,
 	storing the result back to that memory location atomically.
- 
+
 	This function is equivalent to {@link OSAtomicOr32Orig}
 	except that it also introduces a barrier.
     @result Returns the original value referenced by <code>__theValue</code>.
@@ -481,7 +482,7 @@ int32_t	OSAtomicXor32Orig( uint32_t __theMask, volatile uint32_t *__theValue );
 OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_xor)
 __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_2)
 int32_t	OSAtomicXor32OrigBarrier( uint32_t __theMask, volatile uint32_t *__theValue );
- 
+
 
 /*! @group Compare and swap
  * Functions in this group return true if the swap occured.  There are several versions,
@@ -587,7 +588,7 @@ bool	OSAtomicCompareAndSwapIntBarrier( int __oldValue, int __newValue, volatile
 	match, this function stores the value from <code>__newValue</code> into
 	that memory location atomically.
 
-	This function is equivalent to {@link OSAtomicCompareAndSwap32} on 32-bit architectures, 
+	This function is equivalent to {@link OSAtomicCompareAndSwap32} on 32-bit architectures,
 	or {@link OSAtomicCompareAndSwap64} on 64-bit architectures.
     @result Returns TRUE on a match, FALSE otherwise.
  */
@@ -606,7 +607,7 @@ bool	OSAtomicCompareAndSwapLong( long __oldValue, long __newValue, volatile long
 	This function is equivalent to {@link OSAtomicCompareAndSwapLong}
 	except that it also introduces a barrier.
 
-	This function is equivalent to {@link OSAtomicCompareAndSwap32} on 32-bit architectures, 
+	This function is equivalent to {@link OSAtomicCompareAndSwap32} on 32-bit architectures,
 	or {@link OSAtomicCompareAndSwap64} on 64-bit architectures.
     @result Returns TRUE on a match, FALSE otherwise.
  */
@@ -706,7 +707,7 @@ bool    OSAtomicTestAndSetBarrier( uint32_t __n, volatile void *__theAddress );
 	For example, if <code>__theAddress</code> points to a 64-bit value,
 	to compare the value of the most significant bit, you would specify
 	<code>56</code> for <code>__n</code>.
- 
+
     @result
 	Returns the original value of the bit being tested.
  */
@@ -719,15 +720,15 @@ bool    OSAtomicTestAndClear( uint32_t __n, volatile void *__theAddress );
     @discussion
 	This function tests a bit in the value referenced by <code>__theAddress</code>
 	and if it is not cleared, clears it.
- 
+
 	The bit is chosen by the value of <code>__n</code> such that the
 	operation will be performed on bit <code>(0x80 >> (__n & 7))</code>
 	of byte <code>((char *)__theAddress + (n >> 3))</code>.
- 
+
 	For example, if <code>__theAddress</code> points to a 64-bit value,
 	to compare the value of the most significant bit, you would specify
 	<code>56</code> for <code>__n</code>.
- 
+
 	This function is equivalent to {@link OSAtomicTestAndSet}
 	except that it also introduces a barrier.
     @result
@@ -736,7 +737,7 @@ bool    OSAtomicTestAndClear( uint32_t __n, volatile void *__theAddress );
 OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_and)
 __OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
 bool    OSAtomicTestAndClearBarrier( uint32_t __n, volatile void *__theAddress );
- 
+
 
 /*! @group Memory barriers */
 
@@ -1174,4 +1175,92 @@ __END_DECLS
 
 #endif // defined(OSATOMIC_USE_INLINED) && OSATOMIC_USE_INLINED
 
+#if TARGET_OS_OSX || TARGET_OS_DRIVERKIT
+
+__BEGIN_DECLS
+
+/*! @group Lockless atomic fifo enqueue and dequeue
+ * These routines manipulate singly-linked FIFO lists.
+ *
+ * This API is deprecated and no longer recommended
+ */
+
+/*! @abstract The data structure for a fifo queue head.
+    @discussion
+	You should always initialize a fifo queue head structure with the
+	initialization vector {@link OS_ATOMIC_FIFO_QUEUE_INIT} before use.
+ */
+#if defined(__LP64__)
+
+typedef	volatile struct {
+	void	*opaque1;
+	void	*opaque2;
+	int	 opaque3;
+} __attribute__ ((aligned (16))) OSFifoQueueHead;
+
+#else
+
+typedef	volatile struct {
+	void	*opaque1;
+	void	*opaque2;
+	int	 opaque3;
+} OSFifoQueueHead;
+
+#endif
+/*! @abstract The initialization vector for a fifo queue head. */
+#define OS_ATOMIC_FIFO_QUEUE_INIT   { NULL, NULL, 0 }
+
+/*! @abstract Enqueue an element onto a list.
+    @discussion
+	Memory barriers are incorporated as needed to permit thread-safe access
+	to the queue element.
+    @param __list
+	The list on which you want to enqueue the element.
+    @param __new
+	The element to add.
+    @param __offset
+	The "offset" parameter is the offset (in bytes) of the link field
+	from the beginning of the data structure being queued (<code>__new</code>).
+	The link field should be a pointer type.
+	The <code>__offset</code> value needs to be same for all enqueuing and
+	dequeuing operations on the same list, even if different structure types
+	are enqueued on that list.  The use of <code>offsetset()</code>, defined in
+	<code>stddef.h</code> is the common way to specify the <code>__offset</code>
+	value.
+
+	@note
+	This API is deprecated and no longer recommended
+ */
+__API_DEPRECATED("No longer supported", macos(10.7, 11.0))
+void  OSAtomicFifoEnqueue( OSFifoQueueHead *__list, void *__new, size_t __offset);
+
+/*! @abstract Dequeue an element from a list.
+    @discussion
+	Memory barriers are incorporated as needed to permit thread-safe access
+	to the queue element.
+    @param __list
+	The list from which you want to dequeue an element.
+    @param __offset
+	The "offset" parameter is the offset (in bytes) of the link field
+	from the beginning of the data structure being dequeued (<code>__new</code>).
+	The link field should be a pointer type.
+	The <code>__offset</code> value needs to be same for all enqueuing and
+	dequeuing operations on the same list, even if different structure types
+	are enqueued on that list.  The use of <code>offsetset()</code>, defined in
+	<code>stddef.h</code> is the common way to specify the <code>__offset</code>
+	value.
+    @result
+	Returns the oldest enqueued element, or <code>NULL</code> if the
+	list is empty.
+
+	@note
+	This API is deprecated and no longer recommended
+ */
+__API_DEPRECATED("No longer supported", macos(10.7, 11.0))
+void* OSAtomicFifoDequeue( OSFifoQueueHead *__list, size_t __offset);
+
+__END_DECLS
+
+#endif /* TARGET_OS_OSX || TARGET_OS_DRIVERKIT */
+
 #endif /* _OSATOMIC_DEPRECATED_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/libkern/OSAtomicQueue.h b/lib/libc/include/aarch64-macos.13-none/libkern/OSAtomicQueue.h
similarity index 59%
rename from lib/libc/include/x86_64-macos.10-none/libkern/OSAtomicQueue.h
rename to lib/libc/include/aarch64-macos.13-none/libkern/OSAtomicQueue.h
index 3f673861e3..66033fc834 100644
--- a/lib/libc/include/x86_64-macos.10-none/libkern/OSAtomicQueue.h
+++ b/lib/libc/include/aarch64-macos.13-none/libkern/OSAtomicQueue.h
@@ -28,6 +28,7 @@
 #include    <sys/cdefs.h>
 #include    <stdint.h>
 #include    <stdbool.h>
+#include    "OSAtomicDeprecated.h"
 
 #include    <Availability.h>
 
@@ -109,83 +110,6 @@ void  OSAtomicEnqueue( OSQueueHead *__list, void *__new, size_t __offset);
 __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_4_0)
 void* OSAtomicDequeue( OSQueueHead *__list, size_t __offset);
 
-#if defined(__x86_64__) || defined(__i386__)
-
-/*! @group Lockless atomic fifo enqueue and dequeue
- * These routines manipulate singly-linked FIFO lists.
- */
-
-/*! @abstract The data structure for a fifo queue head.
-    @discussion
-	You should always initialize a fifo queue head structure with the
-	initialization vector {@link OS_ATOMIC_FIFO_QUEUE_INIT} before use.
- */
-#if defined(__x86_64__)
-
-typedef	volatile struct {
-	void	*opaque1;
-	void	*opaque2;
-	int	 opaque3;
-} __attribute__ ((aligned (16))) OSFifoQueueHead;
-
-#else
-
-typedef	volatile struct {
-	void	*opaque1;
-	void	*opaque2;
-	int	 opaque3;
-} OSFifoQueueHead;
-
-#endif
-
-/*! @abstract The initialization vector for a fifo queue head. */
-#define OS_ATOMIC_FIFO_QUEUE_INIT   { NULL, NULL, 0 }
-
-/*! @abstract Enqueue an element onto a list.
-    @discussion
-	Memory barriers are incorporated as needed to permit thread-safe access
-	to the queue element.
-    @param __list
-	The list on which you want to enqueue the element.
-    @param __new
-	The element to add.
-    @param __offset
-	The "offset" parameter is the offset (in bytes) of the link field
-	from the beginning of the data structure being queued (<code>__new</code>).
-	The link field should be a pointer type.
-	The <code>__offset</code> value needs to be same for all enqueuing and
-	dequeuing operations on the same list, even if different structure types
-	are enqueued on that list.  The use of <code>offsetset()</code>, defined in
-	<code>stddef.h</code> is the common way to specify the <code>__offset</code>
-	value.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_NA)
-void  OSAtomicFifoEnqueue( OSFifoQueueHead *__list, void *__new, size_t __offset);
-
-/*! @abstract Dequeue an element from a list.
-    @discussion
-	Memory barriers are incorporated as needed to permit thread-safe access
-	to the queue element.
-    @param __list
-	The list from which you want to dequeue an element.
-    @param __offset
-	The "offset" parameter is the offset (in bytes) of the link field
-	from the beginning of the data structure being dequeued (<code>__new</code>).
-	The link field should be a pointer type.
-	The <code>__offset</code> value needs to be same for all enqueuing and
-	dequeuing operations on the same list, even if different structure types
-	are enqueued on that list.  The use of <code>offsetset()</code>, defined in
-	<code>stddef.h</code> is the common way to specify the <code>__offset</code>
-	value.
-    @result
-	Returns the oldest enqueued element, or <code>NULL</code> if the
-	list is empty.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_NA)
-void* OSAtomicFifoDequeue( OSFifoQueueHead *__list, size_t __offset);
-
-#endif /* __i386__ || __x86_64__ */
-
 __END_DECLS
 
 #endif /* _OSATOMICQUEUE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/libkern/OSSpinLockDeprecated.h b/lib/libc/include/aarch64-macos.13-none/libkern/OSSpinLockDeprecated.h
similarity index 100%
rename from lib/libc/include/x86_64-macos.10-none/libkern/OSSpinLockDeprecated.h
rename to lib/libc/include/aarch64-macos.13-none/libkern/OSSpinLockDeprecated.h
diff --git a/lib/libc/include/aarch64-macos.13-none/libkern/arm/OSByteOrder.h b/lib/libc/include/aarch64-macos.13-none/libkern/arm/OSByteOrder.h
new file mode 100644
index 0000000000..f89a24b53f
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/libkern/arm/OSByteOrder.h
@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 1999-2007 Apple Inc. All rights reserved.
+ */
+
+#ifndef _OS_OSBYTEORDERARM_H
+#define _OS_OSBYTEORDERARM_H
+
+#include <stdint.h>
+#include <arm/arch.h> /* for _ARM_ARCH_6 */
+
+/* Generic byte swapping functions. */
+
+__DARWIN_OS_INLINE
+uint16_t
+_OSSwapInt16(
+	uint16_t        _data
+	)
+{
+	/* Reduces to 'rev16' with clang */
+	return (uint16_t)(_data << 8 | _data >> 8);
+}
+
+__DARWIN_OS_INLINE
+uint32_t
+_OSSwapInt32(
+	uint32_t        _data
+	)
+{
+#if defined(__llvm__)
+	_data = __builtin_bswap32(_data);
+#else
+	/* This actually generates the best code */
+	_data = (((_data ^ (_data >> 16 | (_data << 16))) & 0xFF00FFFF) >> 8) ^ (_data >> 8 | _data << 24);
+#endif
+
+	return _data;
+}
+
+__DARWIN_OS_INLINE
+uint64_t
+_OSSwapInt64(
+	uint64_t        _data
+	)
+{
+#if defined(__llvm__)
+	return __builtin_bswap64(_data);
+#else
+	union {
+		uint64_t _ull;
+		uint32_t _ul[2];
+	} _u;
+
+	/* This actually generates the best code */
+	_u._ul[0] = (uint32_t)(_data >> 32);
+	_u._ul[1] = (uint32_t)(_data & 0xffffffff);
+	_u._ul[0] = _OSSwapInt32(_u._ul[0]);
+	_u._ul[1] = _OSSwapInt32(_u._ul[1]);
+	return _u._ull;
+#endif
+}
+
+/* Functions for byte reversed loads. */
+
+struct _OSUnalignedU16 {
+	volatile uint16_t __val;
+} __attribute__((__packed__));
+
+struct _OSUnalignedU32 {
+	volatile uint32_t __val;
+} __attribute__((__packed__));
+
+struct _OSUnalignedU64 {
+	volatile uint64_t __val;
+} __attribute__((__packed__));
+
+#if defined(_POSIX_C_SOURCE) || defined(_XOPEN_SOURCE)
+__DARWIN_OS_INLINE
+uint16_t
+_OSReadSwapInt16(
+	const volatile void   * _base,
+	uintptr_t       _offset
+	)
+{
+	return _OSSwapInt16(((struct _OSUnalignedU16 *)((uintptr_t)_base + _offset))->__val);
+}
+#else
+__DARWIN_OS_INLINE
+uint16_t
+OSReadSwapInt16(
+	const volatile void   * _base,
+	uintptr_t       _offset
+	)
+{
+	return _OSSwapInt16(((struct _OSUnalignedU16 *)((uintptr_t)_base + _offset))->__val);
+}
+#endif
+
+#if defined(_POSIX_C_SOURCE) || defined(_XOPEN_SOURCE)
+__DARWIN_OS_INLINE
+uint32_t
+_OSReadSwapInt32(
+	const volatile void   * _base,
+	uintptr_t       _offset
+	)
+{
+	return _OSSwapInt32(((struct _OSUnalignedU32 *)((uintptr_t)_base + _offset))->__val);
+}
+#else
+__DARWIN_OS_INLINE
+uint32_t
+OSReadSwapInt32(
+	const volatile void   * _base,
+	uintptr_t       _offset
+	)
+{
+	return _OSSwapInt32(((struct _OSUnalignedU32 *)((uintptr_t)_base + _offset))->__val);
+}
+#endif
+
+#if defined(_POSIX_C_SOURCE) || defined(_XOPEN_SOURCE)
+__DARWIN_OS_INLINE
+uint64_t
+_OSReadSwapInt64(
+	const volatile void   * _base,
+	uintptr_t       _offset
+	)
+{
+	return _OSSwapInt64(((struct _OSUnalignedU64 *)((uintptr_t)_base + _offset))->__val);
+}
+#else
+__DARWIN_OS_INLINE
+uint64_t
+OSReadSwapInt64(
+	const volatile void   * _base,
+	uintptr_t       _offset
+	)
+{
+	return _OSSwapInt64(((struct _OSUnalignedU64 *)((uintptr_t)_base + _offset))->__val);
+}
+#endif
+
+/* Functions for byte reversed stores. */
+
+#if defined(_POSIX_C_SOURCE) || defined(_XOPEN_SOURCE)
+__DARWIN_OS_INLINE
+void
+_OSWriteSwapInt16(
+	volatile void   * _base,
+	uintptr_t       _offset,
+	uint16_t        _data
+	)
+{
+	((struct _OSUnalignedU16 *)((uintptr_t)_base + _offset))->__val = _OSSwapInt16(_data);
+}
+#else
+__DARWIN_OS_INLINE
+void
+OSWriteSwapInt16(
+	volatile void   * _base,
+	uintptr_t       _offset,
+	uint16_t        _data
+	)
+{
+	((struct _OSUnalignedU16 *)((uintptr_t)_base + _offset))->__val = _OSSwapInt16(_data);
+}
+#endif
+
+#if defined(_POSIX_C_SOURCE) || defined(_XOPEN_SOURCE)
+__DARWIN_OS_INLINE
+void
+_OSWriteSwapInt32(
+	volatile void   * _base,
+	uintptr_t       _offset,
+	uint32_t        _data
+	)
+{
+	((struct _OSUnalignedU32 *)((uintptr_t)_base + _offset))->__val = _OSSwapInt32(_data);
+}
+#else
+__DARWIN_OS_INLINE
+void
+OSWriteSwapInt32(
+	volatile void   * _base,
+	uintptr_t       _offset,
+	uint32_t        _data
+	)
+{
+	((struct _OSUnalignedU32 *)((uintptr_t)_base + _offset))->__val = _OSSwapInt32(_data);
+}
+#endif
+
+#if defined(_POSIX_C_SOURCE) || defined(_XOPEN_SOURCE)
+__DARWIN_OS_INLINE
+void
+_OSWriteSwapInt64(
+	volatile void    * _base,
+	uintptr_t        _offset,
+	uint64_t         _data
+	)
+{
+	((struct _OSUnalignedU64 *)((uintptr_t)_base + _offset))->__val = _OSSwapInt64(_data);
+}
+#else
+__DARWIN_OS_INLINE
+void
+OSWriteSwapInt64(
+	volatile void    * _base,
+	uintptr_t        _offset,
+	uint64_t         _data
+	)
+{
+	((struct _OSUnalignedU64 *)((uintptr_t)_base + _offset))->__val = _OSSwapInt64(_data);
+}
+#endif
+
+#endif /* ! _OS_OSBYTEORDERARM_H */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-macos.13-none/mach/arm/_structs.h b/lib/libc/include/aarch64-macos.13-none/mach/arm/_structs.h
new file mode 100644
index 0000000000..5bc9ee2f2d
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/mach/arm/_structs.h
@@ -0,0 +1,683 @@
+/*
+ * Copyright (c) 2004-2007 Apple Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+/*
+ * @OSF_COPYRIGHT@
+ */
+#ifndef _MACH_ARM__STRUCTS_H_
+#define _MACH_ARM__STRUCTS_H_
+
+#if defined (__arm__) || defined (__arm64__)
+
+#include <sys/cdefs.h> /* __DARWIN_UNIX03 */
+#include <machine/types.h> /* __uint32_t */
+
+#if __DARWIN_UNIX03
+#define _STRUCT_ARM_EXCEPTION_STATE struct __darwin_arm_exception_state
+_STRUCT_ARM_EXCEPTION_STATE
+{
+	__uint32_t __exception; /* number of arm exception taken */
+	__uint32_t __fsr;       /* Fault status */
+	__uint32_t __far;       /* Virtual Fault Address */
+};
+#else /* !__DARWIN_UNIX03 */
+#define _STRUCT_ARM_EXCEPTION_STATE struct arm_exception_state
+_STRUCT_ARM_EXCEPTION_STATE
+{
+	__uint32_t exception;   /* number of arm exception taken */
+	__uint32_t fsr;         /* Fault status */
+	__uint32_t far;         /* Virtual Fault Address */
+};
+#endif /* __DARWIN_UNIX03 */
+
+#if __DARWIN_UNIX03
+#define _STRUCT_ARM_EXCEPTION_STATE64 struct __darwin_arm_exception_state64
+_STRUCT_ARM_EXCEPTION_STATE64
+{
+	__uint64_t __far;       /* Virtual Fault Address */
+	__uint32_t __esr;       /* Exception syndrome */
+	__uint32_t __exception; /* number of arm exception taken */
+};
+#else /* !__DARWIN_UNIX03 */
+#define _STRUCT_ARM_EXCEPTION_STATE64 struct arm_exception_state64
+_STRUCT_ARM_EXCEPTION_STATE64
+{
+	__uint64_t far;         /* Virtual Fault Address */
+	__uint32_t esr;         /* Exception syndrome */
+	__uint32_t exception;   /* number of arm exception taken */
+};
+#endif /* __DARWIN_UNIX03 */
+
+#if __DARWIN_UNIX03
+#define _STRUCT_ARM_THREAD_STATE struct __darwin_arm_thread_state
+_STRUCT_ARM_THREAD_STATE
+{
+	__uint32_t __r[13]; /* General purpose register r0-r12 */
+	__uint32_t __sp;    /* Stack pointer r13 */
+	__uint32_t __lr;    /* Link register r14 */
+	__uint32_t __pc;    /* Program counter r15 */
+	__uint32_t __cpsr;  /* Current program status register */
+};
+#else /* !__DARWIN_UNIX03 */
+#define _STRUCT_ARM_THREAD_STATE struct arm_thread_state
+_STRUCT_ARM_THREAD_STATE
+{
+	__uint32_t r[13];   /* General purpose register r0-r12 */
+	__uint32_t sp;      /* Stack pointer r13 */
+	__uint32_t lr;      /* Link register r14 */
+	__uint32_t pc;      /* Program counter r15 */
+	__uint32_t cpsr;    /* Current program status register */
+};
+#endif /* __DARWIN_UNIX03 */
+
+
+/*
+ * By default, the pointer fields in the arm_thread_state64_t structure are
+ * opaque on the arm64e architecture and require the use of accessor macros.
+ * This mode can also be enabled on the arm64 architecture by building with
+ * -D__DARWIN_OPAQUE_ARM_THREAD_STATE64=1.
+ */
+#if defined(__arm64__) && defined(__LP64__)
+
+#if __has_feature(ptrauth_calls)
+#define __DARWIN_OPAQUE_ARM_THREAD_STATE64 1
+#define __DARWIN_PTRAUTH_ARM_THREAD_STATE64 1
+#endif /* __has_feature(ptrauth_calls) */
+
+#ifndef __DARWIN_OPAQUE_ARM_THREAD_STATE64
+#define __DARWIN_OPAQUE_ARM_THREAD_STATE64 0
+#endif
+
+#else /* defined(__arm64__) && defined(__LP64__) */
+
+#undef __DARWIN_OPAQUE_ARM_THREAD_STATE64
+#define __DARWIN_OPAQUE_ARM_THREAD_STATE64 0
+
+#endif /* defined(__arm64__) && defined(__LP64__) */
+
+#if __DARWIN_UNIX03
+#define _STRUCT_ARM_THREAD_STATE64 struct __darwin_arm_thread_state64
+#if __DARWIN_OPAQUE_ARM_THREAD_STATE64
+_STRUCT_ARM_THREAD_STATE64
+{
+	__uint64_t __x[29];     /* General purpose registers x0-x28 */
+	void*      __opaque_fp; /* Frame pointer x29 */
+	void*      __opaque_lr; /* Link register x30 */
+	void*      __opaque_sp; /* Stack pointer x31 */
+	void*      __opaque_pc; /* Program counter */
+	__uint32_t __cpsr;      /* Current program status register */
+	__uint32_t __opaque_flags; /* Flags describing structure format */
+};
+#else /* __DARWIN_OPAQUE_ARM_THREAD_STATE64 */
+_STRUCT_ARM_THREAD_STATE64
+{
+	__uint64_t __x[29]; /* General purpose registers x0-x28 */
+	__uint64_t __fp;    /* Frame pointer x29 */
+	__uint64_t __lr;    /* Link register x30 */
+	__uint64_t __sp;    /* Stack pointer x31 */
+	__uint64_t __pc;    /* Program counter */
+	__uint32_t __cpsr;  /* Current program status register */
+	__uint32_t __pad;   /* Same size for 32-bit or 64-bit clients */
+};
+#endif /* __DARWIN_OPAQUE_ARM_THREAD_STATE64 */
+#else /* !__DARWIN_UNIX03 */
+#define _STRUCT_ARM_THREAD_STATE64 struct arm_thread_state64
+#if __DARWIN_OPAQUE_ARM_THREAD_STATE64
+_STRUCT_ARM_THREAD_STATE64
+{
+	__uint64_t x[29];       /* General purpose registers x0-x28 */
+	void*      __opaque_fp; /* Frame pointer x29 */
+	void*      __opaque_lr; /* Link register x30 */
+	void*      __opaque_sp; /* Stack pointer x31 */
+	void*      __opaque_pc; /* Program counter */
+	__uint32_t cpsr;        /* Current program status register */
+	__uint32_t __opaque_flags; /* Flags describing structure format */
+};
+#else /* __DARWIN_OPAQUE_ARM_THREAD_STATE64 */
+_STRUCT_ARM_THREAD_STATE64
+{
+	__uint64_t x[29]; /* General purpose registers x0-x28 */
+	__uint64_t fp;    /* Frame pointer x29 */
+	__uint64_t lr;    /* Link register x30 */
+	__uint64_t sp;    /* Stack pointer x31 */
+	__uint64_t pc;    /* Program counter */
+	__uint32_t cpsr;  /* Current program status register */
+	__uint32_t __pad; /* Same size for 32-bit or 64-bit clients */
+};
+#endif /* __DARWIN_OPAQUE_ARM_THREAD_STATE64 */
+#endif /* __DARWIN_UNIX03 */
+
+#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL && defined(__arm64__)
+
+/* Accessor macros for arm_thread_state64_t pointer fields */
+
+#if __has_feature(ptrauth_calls) && defined(__LP64__)
+#include <ptrauth.h>
+
+#if !__DARWIN_OPAQUE_ARM_THREAD_STATE64 || !__DARWIN_PTRAUTH_ARM_THREAD_STATE64
+#error "Invalid configuration"
+#endif
+
+#define __DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH 0x1
+#define __DARWIN_ARM_THREAD_STATE64_FLAGS_IB_SIGNED_LR 0x2
+#define __DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED_PC 0x4
+#define __DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED_LR 0x8
+
+#define __DARWIN_ARM_THREAD_STATE64_USER_DIVERSIFIER_MASK 0xff000000
+
+/* Return pc field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_pc(ts) \
+	__extension__ ({ const _STRUCT_ARM_THREAD_STATE64 *__tsp = &(ts); \
+	(uintptr_t)(__tsp->__opaque_pc && !(__tsp->__opaque_flags &       \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH) ?                   \
+	ptrauth_auth_data(__tsp->__opaque_pc,                             \
+	ptrauth_key_process_independent_code,                             \
+	((__tsp->__opaque_flags &                                         \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED_PC) == 0 &&       \
+	(__tsp->__opaque_flags &                                          \
+	__DARWIN_ARM_THREAD_STATE64_USER_DIVERSIFIER_MASK)) ?             \
+	ptrauth_blend_discriminator((void *)(unsigned long)               \
+	(__tsp->__opaque_flags &                                          \
+	__DARWIN_ARM_THREAD_STATE64_USER_DIVERSIFIER_MASK),               \
+	ptrauth_string_discriminator("pc")) :                             \
+	ptrauth_string_discriminator("pc")) : __tsp->__opaque_pc); })
+/* Return pc field of arm_thread_state64_t as a function pointer. May return
+ * NULL if a valid function pointer cannot be constructed, the caller should
+ * fall back to the __darwin_arm_thread_state64_get_pc() macro in that case. */
+#define __darwin_arm_thread_state64_get_pc_fptr(ts) \
+	__extension__ ({ const _STRUCT_ARM_THREAD_STATE64 *__tsp = &(ts); \
+	(__tsp->__opaque_pc && !(__tsp->__opaque_flags &                  \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH) ?                   \
+	ptrauth_auth_function(__tsp->__opaque_pc,                         \
+	ptrauth_key_process_independent_code,                             \
+	((__tsp->__opaque_flags &                                         \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED_PC) == 0 &&       \
+	(__tsp->__opaque_flags &                                          \
+	__DARWIN_ARM_THREAD_STATE64_USER_DIVERSIFIER_MASK)) ?             \
+	ptrauth_blend_discriminator((void *)(unsigned long)               \
+	(__tsp->__opaque_flags &                                          \
+	__DARWIN_ARM_THREAD_STATE64_USER_DIVERSIFIER_MASK),               \
+	ptrauth_string_discriminator("pc")) :                             \
+	ptrauth_string_discriminator("pc")) : NULL); })
+/* Set pc field of arm_thread_state64_t to a function pointer */
+#define __darwin_arm_thread_state64_set_pc_fptr(ts, fptr) \
+	__extension__ ({ _STRUCT_ARM_THREAD_STATE64 *__tsp = &(ts);   \
+	__typeof__(fptr) __f = (fptr); __tsp->__opaque_pc =           \
+	(__f ? (!(__tsp->__opaque_flags &                             \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH) ?               \
+	ptrauth_auth_and_resign(__f, ptrauth_key_function_pointer, 0, \
+	ptrauth_key_process_independent_code,                         \
+	(__tsp->__opaque_flags &                                      \
+	__DARWIN_ARM_THREAD_STATE64_USER_DIVERSIFIER_MASK) ?          \
+	ptrauth_blend_discriminator((void *)(unsigned long)           \
+	(__tsp->__opaque_flags &                                      \
+	__DARWIN_ARM_THREAD_STATE64_USER_DIVERSIFIER_MASK),           \
+	ptrauth_string_discriminator("pc")) :                         \
+	ptrauth_string_discriminator("pc")) : ptrauth_auth_data(__f,  \
+	ptrauth_key_function_pointer, 0)) : __f);                     \
+	__tsp->__opaque_flags &=                                      \
+	~__DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED_PC; })
+/* Return lr field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_lr(ts) \
+	__extension__ ({ const _STRUCT_ARM_THREAD_STATE64 *__tsp = &(ts); \
+	(uintptr_t)(__tsp->__opaque_lr && !(__tsp->__opaque_flags & (     \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH |                    \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_IB_SIGNED_LR)) ?                \
+	ptrauth_auth_data(__tsp->__opaque_lr,                             \
+	ptrauth_key_process_independent_code,                             \
+	((__tsp->__opaque_flags &                                         \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED_LR) == 0 &&       \
+	(__tsp->__opaque_flags &                                          \
+	__DARWIN_ARM_THREAD_STATE64_USER_DIVERSIFIER_MASK)) ?             \
+	ptrauth_blend_discriminator((void *)(unsigned long)               \
+	(__tsp->__opaque_flags &                                          \
+	__DARWIN_ARM_THREAD_STATE64_USER_DIVERSIFIER_MASK),               \
+	ptrauth_string_discriminator("lr")) :                             \
+	ptrauth_string_discriminator("lr")) : __tsp->__opaque_lr); })
+/* Return lr field of arm_thread_state64_t as a function pointer. May return
+ * NULL if a valid function pointer cannot be constructed, the caller should
+ * fall back to the __darwin_arm_thread_state64_get_lr() macro in that case. */
+#define __darwin_arm_thread_state64_get_lr_fptr(ts) \
+	__extension__ ({ const _STRUCT_ARM_THREAD_STATE64 *__tsp = &(ts); \
+	(__tsp->__opaque_lr && !(__tsp->__opaque_flags & (                \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH |                    \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_IB_SIGNED_LR)) ?                \
+	ptrauth_auth_function(__tsp->__opaque_lr,                         \
+	ptrauth_key_process_independent_code,                             \
+	((__tsp->__opaque_flags &                                         \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED_LR) == 0 &&       \
+	(__tsp->__opaque_flags &                                          \
+	__DARWIN_ARM_THREAD_STATE64_USER_DIVERSIFIER_MASK)) ?             \
+	ptrauth_blend_discriminator((void *)(unsigned long)               \
+	(__tsp->__opaque_flags &                                          \
+	__DARWIN_ARM_THREAD_STATE64_USER_DIVERSIFIER_MASK),               \
+	ptrauth_string_discriminator("lr")) :                             \
+	ptrauth_string_discriminator("lr")) : NULL); })
+/* Set lr field of arm_thread_state64_t to a function pointer */
+#define __darwin_arm_thread_state64_set_lr_fptr(ts, fptr) \
+	__extension__ ({ _STRUCT_ARM_THREAD_STATE64 *__tsp = &(ts);            \
+	__typeof__(fptr) __f = (fptr); __tsp->__opaque_lr =                    \
+	(__f ? (!(__tsp->__opaque_flags &                                      \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH) ? (__tsp->__opaque_flags \
+	&= ~__DARWIN_ARM_THREAD_STATE64_FLAGS_IB_SIGNED_LR ,                   \
+	ptrauth_auth_and_resign(__f, ptrauth_key_function_pointer, 0,          \
+	ptrauth_key_process_independent_code,                                  \
+	(__tsp->__opaque_flags &                                               \
+	__DARWIN_ARM_THREAD_STATE64_USER_DIVERSIFIER_MASK) ?                   \
+	ptrauth_blend_discriminator((void *)(unsigned long)                    \
+	(__tsp->__opaque_flags &                                               \
+	__DARWIN_ARM_THREAD_STATE64_USER_DIVERSIFIER_MASK),                    \
+	ptrauth_string_discriminator("lr")) :                                  \
+	ptrauth_string_discriminator("lr"))) : ptrauth_auth_data(__f,          \
+	ptrauth_key_function_pointer, 0)) : __f); __tsp->__opaque_flags &=     \
+	~__DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED_LR; })
+/* Return sp field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_sp(ts) \
+	__extension__ ({ const _STRUCT_ARM_THREAD_STATE64 *__tsp = &(ts); \
+	(uintptr_t)(__tsp->__opaque_sp && !(__tsp->__opaque_flags &       \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH) ?                   \
+	ptrauth_auth_data(__tsp->__opaque_sp,                             \
+	ptrauth_key_process_independent_data,                             \
+	ptrauth_string_discriminator("sp")) : __tsp->__opaque_sp); })
+/* Set sp field of arm_thread_state64_t to a data pointer value */
+#define __darwin_arm_thread_state64_set_sp(ts, ptr) \
+	__extension__ ({ _STRUCT_ARM_THREAD_STATE64 *__tsp = &(ts); \
+	void *__p = (void*)(uintptr_t)(ptr); __tsp->__opaque_sp =   \
+	(__p && !(__tsp->__opaque_flags &                           \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH) ?             \
+	ptrauth_sign_unauthenticated(__p,                           \
+	ptrauth_key_process_independent_data,                       \
+	ptrauth_string_discriminator("sp")) : __p); })
+/* Return fp field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_fp(ts) \
+	__extension__ ({ const _STRUCT_ARM_THREAD_STATE64 *__tsp = &(ts); \
+	(uintptr_t)(__tsp->__opaque_fp && !(__tsp->__opaque_flags &       \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH) ?                   \
+	ptrauth_auth_data(__tsp->__opaque_fp,                             \
+	ptrauth_key_process_independent_data,                             \
+	ptrauth_string_discriminator("fp")) : __tsp->__opaque_fp); })
+/* Set fp field of arm_thread_state64_t to a data pointer value */
+#define __darwin_arm_thread_state64_set_fp(ts, ptr) \
+	__extension__ ({ _STRUCT_ARM_THREAD_STATE64 *__tsp = &(ts); \
+	void *__p = (void*)(uintptr_t)(ptr); __tsp->__opaque_fp =   \
+	(__p && !(__tsp->__opaque_flags &                           \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH) ?             \
+	ptrauth_sign_unauthenticated(__p,                           \
+	ptrauth_key_process_independent_data,                       \
+	ptrauth_string_discriminator("fp")) : __p); })
+
+/* Strip ptr auth bits from pc, lr, sp and fp field of arm_thread_state64_t */
+#define __darwin_arm_thread_state64_ptrauth_strip(ts) \
+	__extension__ ({ _STRUCT_ARM_THREAD_STATE64 *__tsp = &(ts);               \
+	__tsp->__opaque_pc = ((__tsp->__opaque_flags &                            \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH) ? __tsp->__opaque_pc :      \
+	ptrauth_strip(__tsp->__opaque_pc, ptrauth_key_process_independent_code)); \
+	__tsp->__opaque_lr = ((__tsp->__opaque_flags &                            \
+	(__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH |                           \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_IB_SIGNED_LR)) ? __tsp->__opaque_lr :   \
+	ptrauth_strip(__tsp->__opaque_lr, ptrauth_key_process_independent_code)); \
+	__tsp->__opaque_sp = ((__tsp->__opaque_flags &                            \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH) ? __tsp->__opaque_sp :      \
+	ptrauth_strip(__tsp->__opaque_sp, ptrauth_key_process_independent_data)); \
+	__tsp->__opaque_fp = ((__tsp->__opaque_flags &                            \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH) ? __tsp->__opaque_fp :      \
+	ptrauth_strip(__tsp->__opaque_fp, ptrauth_key_process_independent_data)); \
+	__tsp->__opaque_flags |=                                                  \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_NO_PTRAUTH; __tsp->__opaque_flags &=    \
+	~(__DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED_PC |                    \
+	__DARWIN_ARM_THREAD_STATE64_FLAGS_KERNEL_SIGNED_LR); })
+
+#else /* __has_feature(ptrauth_calls) && defined(__LP64__) */
+
+#if __DARWIN_OPAQUE_ARM_THREAD_STATE64
+
+#ifndef __LP64__
+#error "Invalid configuration"
+#endif
+
+/* Return pc field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_pc(ts) \
+	((uintptr_t)((ts).__opaque_pc))
+/* Return pc field of arm_thread_state64_t as a function pointer */
+#define __darwin_arm_thread_state64_get_pc_fptr(ts) \
+	((ts).__opaque_pc)
+/* Set pc field of arm_thread_state64_t to a function pointer */
+#define __darwin_arm_thread_state64_set_pc_fptr(ts, fptr) \
+	((ts).__opaque_pc = (fptr))
+/* Return lr field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_lr(ts) \
+	((uintptr_t)((ts).__opaque_lr))
+/* Return lr field of arm_thread_state64_t as a function pointer */
+#define __darwin_arm_thread_state64_get_lr_fptr(ts) \
+	((ts).__opaque_lr)
+/* Set lr field of arm_thread_state64_t to a function pointer */
+#define __darwin_arm_thread_state64_set_lr_fptr(ts, fptr) \
+	((ts).__opaque_lr = (fptr))
+/* Return sp field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_sp(ts) \
+	((uintptr_t)((ts).__opaque_sp))
+/* Set sp field of arm_thread_state64_t to a data pointer value */
+#define __darwin_arm_thread_state64_set_sp(ts, ptr) \
+	((ts).__opaque_sp = (void*)(uintptr_t)(ptr))
+/* Return fp field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_fp(ts) \
+	((uintptr_t)((ts).__opaque_fp))
+/* Set fp field of arm_thread_state64_t to a data pointer value */
+#define __darwin_arm_thread_state64_set_fp(ts, ptr) \
+	((ts).__opaque_fp = (void*)(uintptr_t)(ptr))
+/* Strip ptr auth bits from pc, lr, sp and fp field of arm_thread_state64_t */
+#define __darwin_arm_thread_state64_ptrauth_strip(ts) \
+	(void)(ts)
+
+#else /* __DARWIN_OPAQUE_ARM_THREAD_STATE64 */
+#if __DARWIN_UNIX03
+
+/* Return pc field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_pc(ts) \
+	((ts).__pc)
+/* Return pc field of arm_thread_state64_t as a function pointer */
+#define __darwin_arm_thread_state64_get_pc_fptr(ts) \
+	((void*)(uintptr_t)((ts).__pc))
+/* Set pc field of arm_thread_state64_t to a function pointer */
+#define __darwin_arm_thread_state64_set_pc_fptr(ts, fptr) \
+	((ts).__pc = (uintptr_t)(fptr))
+/* Return lr field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_lr(ts) \
+	((ts).__lr)
+/* Return lr field of arm_thread_state64_t as a function pointer */
+#define __darwin_arm_thread_state64_get_lr_fptr(ts) \
+	((void*)(uintptr_t)((ts).__lr))
+/* Set lr field of arm_thread_state64_t to a function pointer */
+#define __darwin_arm_thread_state64_set_lr_fptr(ts, fptr) \
+	((ts).__lr = (uintptr_t)(fptr))
+/* Return sp field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_sp(ts) \
+	((ts).__sp)
+/* Set sp field of arm_thread_state64_t to a data pointer value */
+#define __darwin_arm_thread_state64_set_sp(ts, ptr) \
+	((ts).__sp = (uintptr_t)(ptr))
+/* Return fp field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_fp(ts) \
+	((ts).__fp)
+/* Set fp field of arm_thread_state64_t to a data pointer value */
+#define __darwin_arm_thread_state64_set_fp(ts, ptr) \
+	((ts).__fp = (uintptr_t)(ptr))
+/* Strip ptr auth bits from pc, lr, sp and fp field of arm_thread_state64_t */
+#define __darwin_arm_thread_state64_ptrauth_strip(ts) \
+	(void)(ts)
+
+#else /* __DARWIN_UNIX03 */
+
+/* Return pc field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_pc(ts) \
+	((ts).pc)
+/* Return pc field of arm_thread_state64_t as a function pointer */
+#define __darwin_arm_thread_state64_get_pc_fptr(ts) \
+	((void*)(uintptr_t)((ts).pc))
+/* Set pc field of arm_thread_state64_t to a function pointer */
+#define __darwin_arm_thread_state64_set_pc_fptr(ts, fptr) \
+	((ts).pc = (uintptr_t)(fptr))
+/* Return lr field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_lr(ts) \
+	((ts).lr)
+/* Return lr field of arm_thread_state64_t as a function pointer */
+#define __darwin_arm_thread_state64_get_lr_fptr(ts) \
+	((void*)(uintptr_t)((ts).lr))
+/* Set lr field of arm_thread_state64_t to a function pointer */
+#define __darwin_arm_thread_state64_set_lr_fptr(ts, fptr) \
+	((ts).lr = (uintptr_t)(fptr))
+/* Return sp field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_sp(ts) \
+	((ts).sp)
+/* Set sp field of arm_thread_state64_t to a data pointer value */
+#define __darwin_arm_thread_state64_set_sp(ts, ptr) \
+	((ts).sp = (uintptr_t)(ptr))
+/* Return fp field of arm_thread_state64_t as a data pointer value */
+#define __darwin_arm_thread_state64_get_fp(ts) \
+	((ts).fp)
+/* Set fp field of arm_thread_state64_t to a data pointer value */
+#define __darwin_arm_thread_state64_set_fp(ts, ptr) \
+	((ts).fp = (uintptr_t)(ptr))
+/* Strip ptr auth bits from pc, lr, sp and fp field of arm_thread_state64_t */
+#define __darwin_arm_thread_state64_ptrauth_strip(ts) \
+	(void)(ts)
+
+#endif /* __DARWIN_UNIX03 */
+#endif /* __DARWIN_OPAQUE_ARM_THREAD_STATE64 */
+
+#endif /* __has_feature(ptrauth_calls) && defined(__LP64__) */
+#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL && defined(__arm64__) */
+
+#if __DARWIN_UNIX03
+#define _STRUCT_ARM_VFP_STATE struct __darwin_arm_vfp_state
+_STRUCT_ARM_VFP_STATE
+{
+	__uint32_t __r[64];
+	__uint32_t __fpscr;
+};
+#else /* !__DARWIN_UNIX03 */
+#define _STRUCT_ARM_VFP_STATE struct arm_vfp_state
+_STRUCT_ARM_VFP_STATE
+{
+	__uint32_t r[64];
+	__uint32_t fpscr;
+};
+#endif /* __DARWIN_UNIX03 */
+
+#if __DARWIN_UNIX03
+#define _STRUCT_ARM_NEON_STATE64 struct __darwin_arm_neon_state64
+#define _STRUCT_ARM_NEON_STATE   struct __darwin_arm_neon_state
+
+#if defined(__arm64__)
+_STRUCT_ARM_NEON_STATE64
+{
+	__uint128_t __v[32];
+	__uint32_t  __fpsr;
+	__uint32_t  __fpcr;
+};
+
+_STRUCT_ARM_NEON_STATE
+{
+	__uint128_t __v[16];
+	__uint32_t  __fpsr;
+	__uint32_t  __fpcr;
+};
+#elif defined(__arm__)
+/*
+ * No 128-bit intrinsic for ARM; leave it opaque for now.
+ */
+_STRUCT_ARM_NEON_STATE64
+{
+	char opaque[(32 * 16) + (2 * sizeof(__uint32_t))];
+} __attribute__((aligned(16)));
+
+_STRUCT_ARM_NEON_STATE
+{
+	char opaque[(16 * 16) + (2 * sizeof(__uint32_t))];
+} __attribute__((aligned(16)));
+
+#else
+#error Unknown architecture.
+#endif
+
+#else /* !__DARWIN_UNIX03 */
+#define _STRUCT_ARM_NEON_STATE64 struct arm_neon_state64
+#define _STRUCT_ARM_NEON_STATE struct arm_neon_state
+
+#if defined(__arm64__)
+_STRUCT_ARM_NEON_STATE64
+{
+	__uint128_t q[32];
+	uint32_t    fpsr;
+	uint32_t    fpcr;
+};
+
+_STRUCT_ARM_NEON_STATE
+{
+	__uint128_t q[16];
+	uint32_t    fpsr;
+	uint32_t    fpcr;
+};
+#elif defined(__arm__)
+/*
+ * No 128-bit intrinsic for ARM; leave it opaque for now.
+ */
+_STRUCT_ARM_NEON_STATE64
+{
+	char opaque[(32 * 16) + (2 * sizeof(__uint32_t))];
+} __attribute__((aligned(16)));
+
+_STRUCT_ARM_NEON_STATE
+{
+	char opaque[(16 * 16) + (2 * sizeof(__uint32_t))];
+} __attribute__((aligned(16)));
+
+#else
+#error Unknown architecture.
+#endif
+
+#endif /* __DARWIN_UNIX03 */
+
+
+#define _STRUCT_ARM_PAGEIN_STATE struct __arm_pagein_state
+_STRUCT_ARM_PAGEIN_STATE
+{
+	int __pagein_error;
+};
+
+/*
+ * Debug State
+ */
+#if defined(__arm__)
+/* Old-fashioned debug state is only for ARM */
+
+#if __DARWIN_UNIX03
+#define _STRUCT_ARM_DEBUG_STATE struct __darwin_arm_debug_state
+_STRUCT_ARM_DEBUG_STATE
+{
+	__uint32_t __bvr[16];
+	__uint32_t __bcr[16];
+	__uint32_t __wvr[16];
+	__uint32_t __wcr[16];
+};
+#else /* !__DARWIN_UNIX03 */
+#define _STRUCT_ARM_DEBUG_STATE struct arm_debug_state
+_STRUCT_ARM_DEBUG_STATE
+{
+	__uint32_t bvr[16];
+	__uint32_t bcr[16];
+	__uint32_t wvr[16];
+	__uint32_t wcr[16];
+};
+#endif /* __DARWIN_UNIX03 */
+
+#elif defined(__arm64__)
+
+/* ARM's arm_debug_state is ARM64's arm_legacy_debug_state */
+
+#if __DARWIN_UNIX03
+#define _STRUCT_ARM_LEGACY_DEBUG_STATE struct __arm_legacy_debug_state
+_STRUCT_ARM_LEGACY_DEBUG_STATE
+{
+	__uint32_t __bvr[16];
+	__uint32_t __bcr[16];
+	__uint32_t __wvr[16];
+	__uint32_t __wcr[16];
+};
+#else /* __DARWIN_UNIX03 */
+#define _STRUCT_ARM_LEGACY_DEBUG_STATE struct arm_legacy_debug_state
+_STRUCT_ARM_LEGACY_DEBUG_STATE
+{
+	__uint32_t bvr[16];
+	__uint32_t bcr[16];
+	__uint32_t wvr[16];
+	__uint32_t wcr[16];
+};
+#endif /* __DARWIN_UNIX03 */
+#else
+#error unknown architecture
+#endif
+
+#if __DARWIN_UNIX03
+#define _STRUCT_ARM_DEBUG_STATE32 struct __darwin_arm_debug_state32
+_STRUCT_ARM_DEBUG_STATE32
+{
+	__uint32_t __bvr[16];
+	__uint32_t __bcr[16];
+	__uint32_t __wvr[16];
+	__uint32_t __wcr[16];
+	__uint64_t __mdscr_el1; /* Bit 0 is SS (Hardware Single Step) */
+};
+
+#define _STRUCT_ARM_DEBUG_STATE64 struct __darwin_arm_debug_state64
+_STRUCT_ARM_DEBUG_STATE64
+{
+	__uint64_t __bvr[16];
+	__uint64_t __bcr[16];
+	__uint64_t __wvr[16];
+	__uint64_t __wcr[16];
+	__uint64_t __mdscr_el1; /* Bit 0 is SS (Hardware Single Step) */
+};
+#else /* !__DARWIN_UNIX03 */
+#define _STRUCT_ARM_DEBUG_STATE32 struct arm_debug_state32
+_STRUCT_ARM_DEBUG_STATE32
+{
+	__uint32_t bvr[16];
+	__uint32_t bcr[16];
+	__uint32_t wvr[16];
+	__uint32_t wcr[16];
+	__uint64_t mdscr_el1; /* Bit 0 is SS (Hardware Single Step) */
+};
+
+#define _STRUCT_ARM_DEBUG_STATE64 struct arm_debug_state64
+_STRUCT_ARM_DEBUG_STATE64
+{
+	__uint64_t bvr[16];
+	__uint64_t bcr[16];
+	__uint64_t wvr[16];
+	__uint64_t wcr[16];
+	__uint64_t mdscr_el1; /* Bit 0 is SS (Hardware Single Step) */
+};
+#endif /* __DARWIN_UNIX03 */
+
+#if __DARWIN_UNIX03
+#define _STRUCT_ARM_CPMU_STATE64 struct __darwin_arm_cpmu_state64
+_STRUCT_ARM_CPMU_STATE64
+{
+	__uint64_t __ctrs[16];
+};
+#else /* __DARWIN_UNIX03 */
+#define _STRUCT_ARM_CPMU_STATE64 struct arm_cpmu_state64
+_STRUCT_ARM_CPMU_STATE64
+{
+	__uint64_t ctrs[16];
+};
+#endif /* !__DARWIN_UNIX03 */
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif /* _MACH_ARM__STRUCTS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/vm_param.h b/lib/libc/include/aarch64-macos.13-none/mach/arm/boolean.h
similarity index 85%
rename from lib/libc/include/x86_64-macos.10-none/mach/vm_param.h
rename to lib/libc/include/aarch64-macos.13-none/mach/arm/boolean.h
index f2ebe0a3ec..9cdf7c237e 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/vm_param.h
+++ b/lib/libc/include/aarch64-macos.13-none/mach/arm/boolean.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -30,7 +30,7 @@
  */
 /*
  * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
+ * Copyright (c) 1991,1990,1989 Carnegie Mellon University
  * All Rights Reserved.
  *
  * Permission to use, copy, modify and distribute this software and its
@@ -55,19 +55,20 @@
  */
 /*
  */
+
 /*
- *	File:	mach/vm_param.h
- *	Author:	Avadis Tevanian, Jr., Michael Wayne Young
- *	Date:	1985
- *
- *	Machine independent virtual memory parameters.
+ *	File:	boolean.h
  *
+ *	Boolean type, for ARM.
  */
 
-#ifndef _MACH_VM_PARAM_H_
-#define _MACH_VM_PARAM_H_
+#ifndef _MACH_ARM_BOOLEAN_H_
+#define _MACH_ARM_BOOLEAN_H_
 
-#include <mach/machine/vm_param.h>
+#if defined (__arm__) || defined (__arm64__)
 
+typedef int             boolean_t;
 
-#endif  /* _MACH_VM_PARAM_H_ */
\ No newline at end of file
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif  /* _MACH_ARM_BOOLEAN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-macos.13-none/mach/arm/exception.h b/lib/libc/include/aarch64-macos.13-none/mach/arm/exception.h
new file mode 100644
index 0000000000..c27dec1b56
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/mach/arm/exception.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2007 Apple Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+
+#ifndef _MACH_ARM_EXCEPTION_H_
+#define _MACH_ARM_EXCEPTION_H_
+
+#if defined (__arm__) || defined (__arm64__)
+
+#define EXC_TYPES_COUNT         14      /* incl. illegal exception 0 */
+
+#define EXC_MASK_MACHINE         0
+
+#define EXCEPTION_CODE_MAX       2      /*  code and subcode */
+
+
+/*
+ *	Trap numbers as defined by the hardware exception vectors.
+ */
+
+/*
+ *      EXC_BAD_INSTRUCTION
+ */
+
+#define EXC_ARM_UNDEFINED       1       /* Undefined */
+
+/*
+ *      EXC_ARITHMETIC
+ */
+
+#define EXC_ARM_FP_UNDEFINED    0       /* Undefined Floating Point Exception */
+#define EXC_ARM_FP_IO           1       /* Invalid Floating Point Operation */
+#define EXC_ARM_FP_DZ           2       /* Floating Point Divide by Zero */
+#define EXC_ARM_FP_OF           3       /* Floating Point Overflow */
+#define EXC_ARM_FP_UF           4       /* Floating Point Underflow */
+#define EXC_ARM_FP_IX           5       /* Inexact Floating Point Result */
+#define EXC_ARM_FP_ID           6       /* Floating Point Denormal Input */
+
+/*
+ *      EXC_BAD_ACCESS
+ *      Note: do not conflict with kern_return_t values returned by vm_fault
+ */
+
+#define EXC_ARM_DA_ALIGN        0x101   /* Alignment Fault */
+#define EXC_ARM_DA_DEBUG        0x102   /* Debug (watch/break) Fault */
+#define EXC_ARM_SP_ALIGN        0x103   /* SP Alignment Fault */
+#define EXC_ARM_SWP             0x104   /* SWP instruction */
+#define EXC_ARM_PAC_FAIL        0x105   /* PAC authentication failure */
+
+/*
+ *	EXC_BREAKPOINT
+ */
+
+#define EXC_ARM_BREAKPOINT      1       /* breakpoint trap */
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif  /* _MACH_ARM_EXCEPTION_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/thread_special_ports.h b/lib/libc/include/aarch64-macos.13-none/mach/arm/kern_return.h
similarity index 72%
rename from lib/libc/include/x86_64-macos.10-none/mach/thread_special_ports.h
rename to lib/libc/include/aarch64-macos.13-none/mach/arm/kern_return.h
index f777e0060c..bfa07951b3 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/thread_special_ports.h
+++ b/lib/libc/include/aarch64-macos.13-none/mach/arm/kern_return.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -30,7 +30,7 @@
  */
 /*
  * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
+ * Copyright (c) 1991,1990,1989 Carnegie Mellon University
  * All Rights Reserved.
  *
  * Permission to use, copy, modify and distribute this software and its
@@ -55,29 +55,24 @@
  */
 /*
  */
-/*
- *	File:	mach/thread_special_ports.h
- *
- *	Defines codes for special_purpose thread ports.  These are NOT
- *	port identifiers - they are only used for the thread_get_special_port
- *	and thread_set_special_port routines.
- *
- */
-
-#ifndef _MACH_THREAD_SPECIAL_PORTS_H_
-#define _MACH_THREAD_SPECIAL_PORTS_H_
-
-#define THREAD_KERNEL_PORT      1       /* Represents the thread to the outside
-	                                 *  world.*/
 
 /*
- *	Definitions for ease of use
+ *	File:	kern_return.h
+ *	Author:	Avadis Tevanian, Jr., Michael Wayne Young
+ *	Date:	1985
+ *
+ *	Machine-dependent kernel return definitions.
  */
 
-#define thread_get_kernel_port(thread, port)    \
-	        (thread_get_special_port((thread), THREAD_KERNEL_PORT, (port)))
+#ifndef _MACH_ARM_KERN_RETURN_H_
+#define _MACH_ARM_KERN_RETURN_H_
 
-#define thread_set_kernel_port(thread, port)    \
-	        (thread_set_special_port((thread), THREAD_KERNEL_PORT, (port)))
+#if defined (__arm__) || defined (__arm64__)
 
-#endif  /* _MACH_THREAD_SPECIAL_PORTS_H_ */
\ No newline at end of file
+#ifndef ASSEMBLER
+typedef int             kern_return_t;
+#endif  /* ASSEMBLER */
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif  /* _MACH_ARM_KERN_RETURN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-macos.13-none/mach/arm/processor_info.h b/lib/libc/include/aarch64-macos.13-none/mach/arm/processor_info.h
new file mode 100644
index 0000000000..a302fbfcd3
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/mach/arm/processor_info.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2007-2018 Apple Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+
+#ifndef _MACH_ARM_PROCESSOR_INFO_H_
+#define _MACH_ARM_PROCESSOR_INFO_H_
+
+#if defined (__arm__) || defined (__arm64__)
+
+#define PROCESSOR_CPU_STAT   0x10000003 /* Low-level CPU statistics */
+#define PROCESSOR_CPU_STAT64 0x10000004 /* Low-level CPU statistics, in full 64-bit */
+
+#include <stdint.h> /* uint32_t, uint64_t */
+
+struct processor_cpu_stat {
+	uint32_t irq_ex_cnt;
+	uint32_t ipi_cnt;
+	uint32_t timer_cnt;
+	uint32_t undef_ex_cnt;
+	uint32_t unaligned_cnt;
+	uint32_t vfp_cnt;
+	uint32_t vfp_shortv_cnt;
+	uint32_t data_ex_cnt;
+	uint32_t instr_ex_cnt;
+};
+
+typedef struct processor_cpu_stat  processor_cpu_stat_data_t;
+typedef struct processor_cpu_stat *processor_cpu_stat_t;
+#define PROCESSOR_CPU_STAT_COUNT ((mach_msg_type_number_t) \
+	        (sizeof(processor_cpu_stat_data_t) / sizeof(natural_t)))
+
+struct processor_cpu_stat64 {
+	uint64_t irq_ex_cnt;
+	uint64_t ipi_cnt;
+	uint64_t timer_cnt;
+	uint64_t undef_ex_cnt;
+	uint64_t unaligned_cnt;
+	uint64_t vfp_cnt;
+	uint64_t vfp_shortv_cnt;
+	uint64_t data_ex_cnt;
+	uint64_t instr_ex_cnt;
+	uint64_t pmi_cnt;
+} __attribute__((packed, aligned(4)));
+
+typedef struct processor_cpu_stat64  processor_cpu_stat64_data_t;
+typedef struct processor_cpu_stat64 *processor_cpu_stat64_t;
+#define PROCESSOR_CPU_STAT64_COUNT ((mach_msg_type_number_t) \
+	        (sizeof(processor_cpu_stat64_data_t) / sizeof(integer_t)))
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif /* _MACH_ARM_PROCESSOR_INFO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/machine/rpc.h b/lib/libc/include/aarch64-macos.13-none/mach/arm/rpc.h
similarity index 86%
rename from lib/libc/include/x86_64-macos.10-none/mach/machine/rpc.h
rename to lib/libc/include/aarch64-macos.13-none/mach/arm/rpc.h
index 7d6ccee5f8..cb100ece01 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/machine/rpc.h
+++ b/lib/libc/include/aarch64-macos.13-none/mach/arm/rpc.h
@@ -25,14 +25,15 @@
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
+/*
+ * @OSF_COPYRIGHT@
+ */
 
-#ifndef _MACH_MACHINE_RPC_H_
-#define _MACH_MACHINE_RPC_H_
+#ifndef _MACH_ARM_RPC_H_
+#define _MACH_ARM_RPC_H_
 
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/rpc.h"
-#else
-#error architecture not supported
-#endif
+#if defined (__arm__) || defined (__arm64__)
 
-#endif  /* _MACH_MACHINE_RPC_H_ */
\ No newline at end of file
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif /* _MACH_ARM_RPC_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/machine/types.h b/lib/libc/include/aarch64-macos.13-none/mach/arm/thread_state.h
similarity index 78%
rename from lib/libc/include/x86_64-macos.10-none/machine/types.h
rename to lib/libc/include/aarch64-macos.13-none/mach/arm/thread_state.h
index 5d1a1e575f..d72a3c2013 100644
--- a/lib/libc/include/x86_64-macos.10-none/machine/types.h
+++ b/lib/libc/include/aarch64-macos.13-none/mach/arm/thread_state.h
@@ -26,15 +26,17 @@
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 /*
- * Copyright 1995 NeXT Computer, Inc. All rights reserved.
+ * @OSF_COPYRIGHT@
  */
-#ifndef _BSD_MACHINE_TYPES_H_
-#define _BSD_MACHINE_TYPES_H_
 
-#if defined (__i386__) || defined(__x86_64__)
-#include "i386/types.h"
-#else
-#error architecture not supported
-#endif
+#ifndef _MACH_ARM_THREAD_STATE_H_
+#define _MACH_ARM_THREAD_STATE_H_
 
-#endif /* _BSD_MACHINE_TYPES_H_ */
\ No newline at end of file
+#if defined (__arm__) || defined (__arm64__)
+
+/* Size of maximum exported thread state in words */
+#define ARM_THREAD_STATE_MAX    (1296)    /* Size of biggest state possible */
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif  /* _MACH_ARM_THREAD_STATE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-macos.13-none/mach/arm/thread_status.h b/lib/libc/include/aarch64-macos.13-none/mach/arm/thread_status.h
new file mode 100644
index 0000000000..f270b61fc6
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/mach/arm/thread_status.h
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 2007 Apple Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+/*
+ * FILE_ID: thread_status.h
+ */
+
+
+#ifndef _ARM_THREAD_STATUS_H_
+#define _ARM_THREAD_STATUS_H_
+
+#if defined (__arm__) || defined (__arm64__)
+
+#include <mach/machine/_structs.h>
+#include <mach/machine/thread_state.h>
+#include <mach/message.h>
+#include <mach/vm_types.h>
+
+
+/*
+ *    Support for determining the state of a thread
+ */
+
+
+/*
+ *  Flavors
+ */
+
+#define ARM_THREAD_STATE         1
+#define ARM_UNIFIED_THREAD_STATE ARM_THREAD_STATE
+#define ARM_VFP_STATE            2
+#define ARM_EXCEPTION_STATE      3
+#define ARM_DEBUG_STATE          4 /* pre-armv8 */
+#define THREAD_STATE_NONE        5
+#define ARM_THREAD_STATE64       6
+#define ARM_EXCEPTION_STATE64    7
+//      ARM_THREAD_STATE_LAST    8 /* legacy */
+#define ARM_THREAD_STATE32       9
+
+
+/* API */
+#define ARM_DEBUG_STATE32        14
+#define ARM_DEBUG_STATE64        15
+#define ARM_NEON_STATE           16
+#define ARM_NEON_STATE64         17
+#define ARM_CPMU_STATE64         18
+
+
+#define ARM_PAGEIN_STATE         27
+
+#ifndef ARM_STATE_FLAVOR_IS_OTHER_VALID
+#define ARM_STATE_FLAVOR_IS_OTHER_VALID(_flavor_) 0
+#endif
+
+#define VALID_THREAD_STATE_FLAVOR(x) \
+	((x == ARM_THREAD_STATE) ||           \
+	 (x == ARM_VFP_STATE) ||              \
+	 (x == ARM_EXCEPTION_STATE) ||        \
+	 (x == ARM_DEBUG_STATE) ||            \
+	 (x == THREAD_STATE_NONE) ||          \
+	 (x == ARM_THREAD_STATE32) ||         \
+	 (x == ARM_THREAD_STATE64) ||         \
+	 (x == ARM_EXCEPTION_STATE64) ||      \
+	 (x == ARM_NEON_STATE) ||             \
+	 (x == ARM_NEON_STATE64) ||           \
+	 (x == ARM_DEBUG_STATE32) ||          \
+	 (x == ARM_DEBUG_STATE64) ||          \
+	 (x == ARM_PAGEIN_STATE) ||           \
+	 (ARM_STATE_FLAVOR_IS_OTHER_VALID(x)))
+
+struct arm_state_hdr {
+	uint32_t flavor;
+	uint32_t count;
+};
+typedef struct arm_state_hdr arm_state_hdr_t;
+
+typedef _STRUCT_ARM_THREAD_STATE   arm_thread_state_t;
+typedef _STRUCT_ARM_THREAD_STATE   arm_thread_state32_t;
+typedef _STRUCT_ARM_THREAD_STATE64 arm_thread_state64_t;
+
+#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL && defined(__arm64__)
+
+/* Accessor macros for arm_thread_state64_t pointer fields */
+
+/* Return pc field of arm_thread_state64_t as a data pointer value */
+#define arm_thread_state64_get_pc(ts) \
+	        __darwin_arm_thread_state64_get_pc(ts)
+/* Return pc field of arm_thread_state64_t as a function pointer. May return
+ * NULL if a valid function pointer cannot be constructed, the caller should
+ * fall back to the arm_thread_state64_get_pc() macro in that case. */
+#define arm_thread_state64_get_pc_fptr(ts) \
+	        __darwin_arm_thread_state64_get_pc_fptr(ts)
+/* Set pc field of arm_thread_state64_t to a function pointer */
+#define arm_thread_state64_set_pc_fptr(ts, fptr) \
+	        __darwin_arm_thread_state64_set_pc_fptr(ts, fptr)
+/* Return lr field of arm_thread_state64_t as a data pointer value */
+#define arm_thread_state64_get_lr(ts) \
+	        __darwin_arm_thread_state64_get_lr(ts)
+/* Return lr field of arm_thread_state64_t as a function pointer. May return
+ * NULL if a valid function pointer cannot be constructed, the caller should
+ * fall back to the arm_thread_state64_get_lr() macro in that case. */
+#define arm_thread_state64_get_lr_fptr(ts) \
+	        __darwin_arm_thread_state64_get_lr_fptr(ts)
+/* Set lr field of arm_thread_state64_t to a function pointer */
+#define arm_thread_state64_set_lr_fptr(ts, fptr) \
+	        __darwin_arm_thread_state64_set_lr_fptr(ts, fptr)
+/* Return sp field of arm_thread_state64_t as a data pointer value */
+#define arm_thread_state64_get_sp(ts) \
+	        __darwin_arm_thread_state64_get_sp(ts)
+/* Set sp field of arm_thread_state64_t to a data pointer value */
+#define arm_thread_state64_set_sp(ts, ptr) \
+	        __darwin_arm_thread_state64_set_sp(ts, ptr)
+/* Return fp field of arm_thread_state64_t as a data pointer value */
+#define arm_thread_state64_get_fp(ts) \
+	        __darwin_arm_thread_state64_get_fp(ts)
+/* Set fp field of arm_thread_state64_t to a data pointer value */
+#define arm_thread_state64_set_fp(ts, ptr) \
+	        __darwin_arm_thread_state64_set_fp(ts, ptr)
+/* Strip ptr auth bits from pc, lr, sp and fp field of arm_thread_state64_t */
+#define arm_thread_state64_ptrauth_strip(ts) \
+	        __darwin_arm_thread_state64_ptrauth_strip(ts)
+
+#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL && defined(__arm64__) */
+
+struct arm_unified_thread_state {
+	arm_state_hdr_t ash;
+	union {
+		arm_thread_state32_t ts_32;
+		arm_thread_state64_t ts_64;
+	} uts;
+};
+#define ts_32 uts.ts_32
+#define ts_64 uts.ts_64
+typedef struct arm_unified_thread_state arm_unified_thread_state_t;
+
+#define ARM_THREAD_STATE_COUNT ((mach_msg_type_number_t) \
+	(sizeof (arm_thread_state_t)/sizeof(uint32_t)))
+#define ARM_THREAD_STATE32_COUNT ((mach_msg_type_number_t) \
+	(sizeof (arm_thread_state32_t)/sizeof(uint32_t)))
+#define ARM_THREAD_STATE64_COUNT ((mach_msg_type_number_t) \
+	(sizeof (arm_thread_state64_t)/sizeof(uint32_t)))
+#define ARM_UNIFIED_THREAD_STATE_COUNT ((mach_msg_type_number_t) \
+	(sizeof (arm_unified_thread_state_t)/sizeof(uint32_t)))
+
+
+typedef _STRUCT_ARM_VFP_STATE         arm_vfp_state_t;
+typedef _STRUCT_ARM_NEON_STATE        arm_neon_state_t;
+typedef _STRUCT_ARM_NEON_STATE        arm_neon_state32_t;
+typedef _STRUCT_ARM_NEON_STATE64      arm_neon_state64_t;
+
+
+typedef _STRUCT_ARM_EXCEPTION_STATE   arm_exception_state_t;
+typedef _STRUCT_ARM_EXCEPTION_STATE   arm_exception_state32_t;
+typedef _STRUCT_ARM_EXCEPTION_STATE64 arm_exception_state64_t;
+
+typedef _STRUCT_ARM_DEBUG_STATE32     arm_debug_state32_t;
+typedef _STRUCT_ARM_DEBUG_STATE64     arm_debug_state64_t;
+
+typedef _STRUCT_ARM_PAGEIN_STATE      arm_pagein_state_t;
+
+/*
+ * Otherwise not ARM64 kernel and we must preserve legacy ARM definitions of
+ * arm_debug_state for binary compatability of userland consumers of this file.
+ */
+#if defined(__arm__)
+typedef _STRUCT_ARM_DEBUG_STATE        arm_debug_state_t;
+#elif defined(__arm64__)
+typedef _STRUCT_ARM_LEGACY_DEBUG_STATE arm_debug_state_t;
+#else /* defined(__arm__) */
+#error Undefined architecture
+#endif /* defined(__arm__) */
+
+#define ARM_VFP_STATE_COUNT ((mach_msg_type_number_t) \
+	(sizeof (arm_vfp_state_t)/sizeof(uint32_t)))
+
+#define ARM_EXCEPTION_STATE_COUNT ((mach_msg_type_number_t) \
+	(sizeof (arm_exception_state_t)/sizeof(uint32_t)))
+
+#define ARM_EXCEPTION_STATE64_COUNT ((mach_msg_type_number_t) \
+	(sizeof (arm_exception_state64_t)/sizeof(uint32_t)))
+
+#define ARM_DEBUG_STATE_COUNT ((mach_msg_type_number_t) \
+	(sizeof (arm_debug_state_t)/sizeof(uint32_t)))
+
+#define ARM_DEBUG_STATE32_COUNT ((mach_msg_type_number_t) \
+	(sizeof (arm_debug_state32_t)/sizeof(uint32_t)))
+
+#define ARM_PAGEIN_STATE_COUNT ((mach_msg_type_number_t) \
+	(sizeof (arm_pagein_state_t)/sizeof(uint32_t)))
+
+#define ARM_DEBUG_STATE64_COUNT ((mach_msg_type_number_t) \
+	(sizeof (arm_debug_state64_t)/sizeof(uint32_t)))
+
+#define ARM_NEON_STATE_COUNT ((mach_msg_type_number_t) \
+	(sizeof (arm_neon_state_t)/sizeof(uint32_t)))
+
+#define ARM_NEON_STATE64_COUNT ((mach_msg_type_number_t) \
+	(sizeof (arm_neon_state64_t)/sizeof(uint32_t)))
+
+#define MACHINE_THREAD_STATE       ARM_THREAD_STATE
+#define MACHINE_THREAD_STATE_COUNT ARM_UNIFIED_THREAD_STATE_COUNT
+
+
+/*
+ * Largest state on this machine:
+ */
+#define THREAD_MACHINE_STATE_MAX THREAD_STATE_MAX
+
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif /* _ARM_THREAD_STATUS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-macos.13-none/mach/arm/vm_param.h b/lib/libc/include/aarch64-macos.13-none/mach/arm/vm_param.h
new file mode 100644
index 0000000000..6915e15f85
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/mach/arm/vm_param.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2007 Apple Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+/*
+ * FILE_ID: vm_param.h
+ */
+
+/*
+ *	ARM machine dependent virtual memory parameters.
+ */
+
+#ifndef _MACH_ARM_VM_PARAM_H_
+#define _MACH_ARM_VM_PARAM_H_
+
+#if defined (__arm__) || defined (__arm64__)
+
+
+
+#if !defined (KERNEL) && !defined (__ASSEMBLER__)
+#include <mach/vm_page_size.h>
+#endif
+
+#define BYTE_SIZE       8       /* byte size in bits */
+
+
+#define PAGE_SHIFT                      vm_page_shift
+#define PAGE_SIZE                       vm_page_size
+#define PAGE_MASK                       vm_page_mask
+
+#define VM_PAGE_SIZE            vm_page_size
+
+#define machine_ptob(x)         ((x) << PAGE_SHIFT)
+
+
+#define PAGE_MAX_SHIFT          14
+#define PAGE_MAX_SIZE           (1 << PAGE_MAX_SHIFT)
+#define PAGE_MAX_MASK           (PAGE_MAX_SIZE-1)
+
+#define PAGE_MIN_SHIFT          12
+#define PAGE_MIN_SIZE           (1 << PAGE_MIN_SHIFT)
+#define PAGE_MIN_MASK           (PAGE_MIN_SIZE-1)
+
+#define VM_MAX_PAGE_ADDRESS     MACH_VM_MAX_ADDRESS
+
+#ifndef __ASSEMBLER__
+
+
+#if defined (__arm__)
+
+#define VM_MIN_ADDRESS          ((vm_address_t) 0x00000000)
+#define VM_MAX_ADDRESS          ((vm_address_t) 0x80000000)
+
+/* system-wide values */
+#define MACH_VM_MIN_ADDRESS     ((mach_vm_offset_t) 0)
+#define MACH_VM_MAX_ADDRESS     ((mach_vm_offset_t) VM_MAX_ADDRESS)
+
+#elif defined (__arm64__)
+
+#define VM_MIN_ADDRESS          ((vm_address_t) 0x0000000000000000ULL)
+#define VM_MAX_ADDRESS          ((vm_address_t) 0x00000000F0000000ULL)
+
+/* system-wide values */
+#define MACH_VM_MIN_ADDRESS_RAW 0x0ULL
+#define MACH_VM_MAX_ADDRESS_RAW 0x00007FFFFE000000ULL
+
+#define MACH_VM_MIN_ADDRESS     ((mach_vm_offset_t) MACH_VM_MIN_ADDRESS_RAW)
+#define MACH_VM_MAX_ADDRESS     ((mach_vm_offset_t) MACH_VM_MAX_ADDRESS_RAW)
+
+#define MACH_VM_MIN_GPU_CARVEOUT_ADDRESS_RAW 0x0000001000000000ULL
+#define MACH_VM_MAX_GPU_CARVEOUT_ADDRESS_RAW 0x0000007000000000ULL
+#define MACH_VM_MIN_GPU_CARVEOUT_ADDRESS     ((mach_vm_offset_t) MACH_VM_MIN_GPU_CARVEOUT_ADDRESS_RAW)
+#define MACH_VM_MAX_GPU_CARVEOUT_ADDRESS     ((mach_vm_offset_t) MACH_VM_MAX_GPU_CARVEOUT_ADDRESS_RAW)
+
+#else /* defined(__arm64__) */
+#error architecture not supported
+#endif
+
+#define VM_MAP_MIN_ADDRESS      VM_MIN_ADDRESS
+#define VM_MAP_MAX_ADDRESS      VM_MAX_ADDRESS
+
+
+#endif  /* !__ASSEMBLER__ */
+
+#define SWI_SYSCALL     0x80
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif  /* _MACH_ARM_VM_PARAM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/aarch64-macos.13-none/mach/arm/vm_types.h b/lib/libc/include/aarch64-macos.13-none/mach/arm/vm_types.h
new file mode 100644
index 0000000000..396923d4c2
--- /dev/null
+++ b/lib/libc/include/aarch64-macos.13-none/mach/arm/vm_types.h
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+/*
+ * @OSF_COPYRIGHT@
+ */
+/*
+ * Mach Operating System
+ * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
+ * All Rights Reserved.
+ *
+ * Permission to use, copy, modify and distribute this software and its
+ * documentation is hereby granted, provided that both the copyright
+ * notice and this permission notice appear in all copies of the
+ * software, derivative works or modified versions, and any portions
+ * thereof, and that both notices appear in supporting documentation.
+ *
+ * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
+ * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ *
+ * Carnegie Mellon requests users of this software to return to
+ *
+ *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
+ *  School of Computer Science
+ *  Carnegie Mellon University
+ *  Pittsburgh PA 15213-3890
+ *
+ * any improvements or extensions that they make and grant Carnegie Mellon
+ * the rights to redistribute these changes.
+ */
+/*
+ */
+
+/*
+ *	File:	vm_types.h
+ *	Author:	Avadis Tevanian, Jr.
+ *	Date: 1985
+ *
+ *	Header file for VM data types.  ARM version.
+ */
+
+#ifndef _MACH_ARM_VM_TYPES_H_
+#define _MACH_ARM_VM_TYPES_H_
+
+#if defined (__arm__) || defined (__arm64__)
+
+#ifndef ASSEMBLER
+
+#include <arm/_types.h>
+#include <stdint.h>
+#include <Availability.h>
+#include <sys/cdefs.h>
+
+/*
+ * natural_t and integer_t are Mach's legacy types for machine-
+ * independent integer types (unsigned, and signed, respectively).
+ * Their original purpose was to define other types in a machine/
+ * compiler independent way.
+ *
+ * They also had an implicit "same size as pointer" characteristic
+ * to them (i.e. Mach's traditional types are very ILP32 or ILP64
+ * centric).  We will likely support x86 ABIs that do not follow
+ * either ofthese models (specifically LP64).  Therefore, we had to
+ * make a choice between making these types scale with pointers or stay
+ * tied to integers.  Because their use is predominantly tied to
+ * to the size of an integer, we are keeping that association and
+ * breaking free from pointer size guarantees.
+ *
+ * New use of these types is discouraged.
+ */
+typedef __darwin_natural_t      natural_t;
+typedef int                     integer_t;
+
+/*
+ * A vm_offset_t is a type-neutral pointer,
+ * e.g. an offset into a virtual memory space.
+ */
+#ifdef __LP64__
+typedef uintptr_t               vm_offset_t __kernel_ptr_semantics;
+typedef uintptr_t               vm_size_t;
+
+typedef uint64_t                mach_vm_address_t __kernel_ptr_semantics;
+typedef uint64_t                mach_vm_offset_t __kernel_ptr_semantics;
+typedef uint64_t                mach_vm_size_t;
+
+typedef uint64_t                vm_map_offset_t __kernel_ptr_semantics;
+typedef uint64_t                vm_map_address_t __kernel_ptr_semantics;
+typedef uint64_t                vm_map_size_t;
+#else
+typedef natural_t               vm_offset_t __kernel_ptr_semantics;
+/*
+ * A vm_size_t is the proper type for e.g.
+ * expressing the difference between two
+ * vm_offset_t entities.
+ */
+typedef natural_t               vm_size_t;
+
+/*
+ * This new type is independent of a particular vm map's
+ * implementation size - and represents appropriate types
+ * for all possible maps.  This is used for interfaces
+ * where the size of the map is not known - or we don't
+ * want to have to distinguish.
+ */
+#if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && (__IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_5_0)
+typedef uint32_t                mach_vm_address_t;
+typedef uint32_t                mach_vm_offset_t;
+typedef uint32_t                mach_vm_size_t;
+#else
+typedef uint64_t                mach_vm_address_t __kernel_ptr_semantics;
+typedef uint64_t                mach_vm_offset_t __kernel_ptr_semantics;
+typedef uint64_t                mach_vm_size_t;
+#endif
+
+typedef uint32_t                vm_map_offset_t __kernel_ptr_semantics;
+typedef uint32_t                vm_map_address_t __kernel_ptr_semantics;
+typedef uint32_t                vm_map_size_t;
+#endif /* __LP64__ */
+
+
+typedef uint32_t                vm32_offset_t;
+typedef uint32_t                vm32_address_t;
+typedef uint32_t                vm32_size_t;
+
+typedef vm_offset_t             mach_port_context_t;
+
+
+#endif  /* ASSEMBLER */
+
+/*
+ * If composing messages by hand (please do not)
+ */
+#define MACH_MSG_TYPE_INTEGER_T MACH_MSG_TYPE_INTEGER_32
+
+#endif /* defined (__arm__) || defined (__arm64__) */
+
+#endif  /* _MACH_ARM_VM_TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.12-any/TargetConditionals.h b/lib/libc/include/any-macos-any/TargetConditionals.h
similarity index 100%
rename from lib/libc/include/any-macos.12-any/TargetConditionals.h
rename to lib/libc/include/any-macos-any/TargetConditionals.h
diff --git a/lib/libc/include/any-macos.12-any/mach/mach_init.h b/lib/libc/include/any-macos-any/mach/mach_init.h
similarity index 100%
rename from lib/libc/include/any-macos.12-any/mach/mach_init.h
rename to lib/libc/include/any-macos-any/mach/mach_init.h
diff --git a/lib/libc/include/any-macos.12-any/mach/task_info.h b/lib/libc/include/any-macos-any/mach/task_info.h
similarity index 100%
rename from lib/libc/include/any-macos.12-any/mach/task_info.h
rename to lib/libc/include/any-macos-any/mach/task_info.h
diff --git a/lib/libc/include/any-macos.12-any/spawn.h b/lib/libc/include/any-macos-any/spawn.h
similarity index 100%
rename from lib/libc/include/any-macos.12-any/spawn.h
rename to lib/libc/include/any-macos-any/spawn.h
diff --git a/lib/libc/include/any-macos.12-any/sys/attr.h b/lib/libc/include/any-macos-any/sys/attr.h
similarity index 100%
rename from lib/libc/include/any-macos.12-any/sys/attr.h
rename to lib/libc/include/any-macos-any/sys/attr.h
diff --git a/lib/libc/include/any-macos-any/sys/stdio.h b/lib/libc/include/any-macos-any/sys/stdio.h
index c51c1b9c7d..da56fdf6c9 100644
--- a/lib/libc/include/any-macos-any/sys/stdio.h
+++ b/lib/libc/include/any-macos-any/sys/stdio.h
@@ -31,6 +31,14 @@
 
 #include <sys/cdefs.h>
 
+#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
+#define RENAME_SECLUDE                  0x00000001
+#define RENAME_SWAP                     0x00000002
+#define RENAME_EXCL                     0x00000004
+#define RENAME_RESERVED1                0x00000008
+#define RENAME_NOFOLLOW_ANY             0x00000010
+#endif
+
 #if __DARWIN_C_LEVEL >= 200809L
 #include <Availability.h>
 
@@ -40,9 +48,6 @@ int     renameat(int, const char *, int, const char *) __OSX_AVAILABLE_STARTING(
 
 #if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
 
-#define RENAME_SECLUDE          0x00000001
-#define RENAME_SWAP                     0x00000002
-#define RENAME_EXCL                     0x00000004
 int renamex_np(const char *, const char *, unsigned int) __OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0) __TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0);
 int renameatx_np(int, const char *, int, const char *, unsigned int) __OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0) __TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0);
 
diff --git a/lib/libc/include/any-macos.12-any/time.h b/lib/libc/include/any-macos-any/time.h
similarity index 100%
rename from lib/libc/include/any-macos.12-any/time.h
rename to lib/libc/include/any-macos-any/time.h
diff --git a/lib/libc/include/any-macos-any/copyfile.h b/lib/libc/include/any-macos.11-any/copyfile.h
similarity index 100%
rename from lib/libc/include/any-macos-any/copyfile.h
rename to lib/libc/include/any-macos.11-any/copyfile.h
diff --git a/lib/libc/include/any-macos.12-any/sys/stdio.h b/lib/libc/include/any-macos.11-any/sys/stdio.h
similarity index 91%
rename from lib/libc/include/any-macos.12-any/sys/stdio.h
rename to lib/libc/include/any-macos.11-any/sys/stdio.h
index da56fdf6c9..c51c1b9c7d 100644
--- a/lib/libc/include/any-macos.12-any/sys/stdio.h
+++ b/lib/libc/include/any-macos.11-any/sys/stdio.h
@@ -31,14 +31,6 @@
 
 #include <sys/cdefs.h>
 
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#define RENAME_SECLUDE                  0x00000001
-#define RENAME_SWAP                     0x00000002
-#define RENAME_EXCL                     0x00000004
-#define RENAME_RESERVED1                0x00000008
-#define RENAME_NOFOLLOW_ANY             0x00000010
-#endif
-
 #if __DARWIN_C_LEVEL >= 200809L
 #include <Availability.h>
 
@@ -48,6 +40,9 @@ int     renameat(int, const char *, int, const char *) __OSX_AVAILABLE_STARTING(
 
 #if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
 
+#define RENAME_SECLUDE          0x00000001
+#define RENAME_SWAP                     0x00000002
+#define RENAME_EXCL                     0x00000004
 int renamex_np(const char *, const char *, unsigned int) __OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0) __TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0);
 int renameatx_np(int, const char *, int, const char *, unsigned int) __OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0) __TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0);
 
diff --git a/lib/libc/include/any-macos-any/sys/unistd.h b/lib/libc/include/any-macos.11-any/sys/unistd.h
similarity index 100%
rename from lib/libc/include/any-macos-any/sys/unistd.h
rename to lib/libc/include/any-macos.11-any/sys/unistd.h
diff --git a/lib/libc/include/x86_64-macos.10-none/Availability.h b/lib/libc/include/any-macos.13-any/Availability.h
similarity index 77%
rename from lib/libc/include/x86_64-macos.10-none/Availability.h
rename to lib/libc/include/any-macos.13-any/Availability.h
index bdfd794d89..2780aa571f 100644
--- a/lib/libc/include/x86_64-macos.10-none/Availability.h
+++ b/lib/libc/include/any-macos.13-any/Availability.h
@@ -132,130 +132,37 @@
 #define __API_TO_BE_DEPRECATED 100000
 #endif
 
-#ifndef __MAC_10_0
-#define __MAC_10_0            1000
-#define __MAC_10_1            1010
-#define __MAC_10_2            1020
-#define __MAC_10_3            1030
-#define __MAC_10_4            1040
-#define __MAC_10_5            1050
-#define __MAC_10_6            1060
-#define __MAC_10_7            1070
-#define __MAC_10_8            1080
-#define __MAC_10_9            1090
-#define __MAC_10_10         101000
-#define __MAC_10_10_2       101002
-#define __MAC_10_10_3       101003
-#define __MAC_10_11         101100
-#define __MAC_10_11_2       101102
-#define __MAC_10_11_3       101103
-#define __MAC_10_11_4       101104
-#define __MAC_10_12         101200
-#define __MAC_10_12_1       101201
-#define __MAC_10_12_2       101202
-#define __MAC_10_12_4       101204
-#define __MAC_10_13         101300
-#define __MAC_10_13_1       101301
-#define __MAC_10_13_2       101302
-#define __MAC_10_13_4       101304
-#define __MAC_10_14         101400
-#define __MAC_10_14_1       101401
-#define __MAC_10_14_4       101404
-#define __MAC_10_15         101500
-#define __MAC_10_15_1       101501
-#define __MAC_10_15_4       101504
-/* __MAC_NA is not defined to a value but is uses as a token by macros to indicate that the API is unavailable */
+#ifndef __API_TO_BE_DEPRECATED_MACOS
+#define __API_TO_BE_DEPRECATED_MACOS 100000
+#endif
 
-#define __IPHONE_2_0      20000
-#define __IPHONE_2_1      20100
-#define __IPHONE_2_2      20200
-#define __IPHONE_3_0      30000
-#define __IPHONE_3_1      30100
-#define __IPHONE_3_2      30200
-#define __IPHONE_4_0      40000
-#define __IPHONE_4_1      40100
-#define __IPHONE_4_2      40200
-#define __IPHONE_4_3      40300
-#define __IPHONE_5_0      50000
-#define __IPHONE_5_1      50100
-#define __IPHONE_6_0      60000
-#define __IPHONE_6_1      60100
-#define __IPHONE_7_0      70000
-#define __IPHONE_7_1      70100
-#define __IPHONE_8_0      80000
-#define __IPHONE_8_1      80100
-#define __IPHONE_8_2      80200
-#define __IPHONE_8_3      80300
-#define __IPHONE_8_4      80400
-#define __IPHONE_9_0      90000
-#define __IPHONE_9_1      90100
-#define __IPHONE_9_2      90200
-#define __IPHONE_9_3      90300
-#define __IPHONE_10_0    100000
-#define __IPHONE_10_1    100100
-#define __IPHONE_10_2    100200
-#define __IPHONE_10_3    100300
-#define __IPHONE_11_0    110000
-#define __IPHONE_11_1    110100
-#define __IPHONE_11_2    110200
-#define __IPHONE_11_3    110300
-#define __IPHONE_11_4    110400
-#define __IPHONE_12_0    120000
-#define __IPHONE_12_1    120100
-#define __IPHONE_12_2    120200
-#define __IPHONE_12_3    120300
-#define __IPHONE_13_0    130000
-#define __IPHONE_13_1    130100
-#define __IPHONE_13_2    130200
-#define __IPHONE_13_3    130300
-#define __IPHONE_13_4    130400
-#define __IPHONE_13_5    130500
-#define __IPHONE_13_6    130600
-/* __IPHONE_NA is not defined to a value but is uses as a token by macros to indicate that the API is unavailable */
+#ifndef __API_TO_BE_DEPRECATED_IOS
+#define __API_TO_BE_DEPRECATED_IOS 100000
+#endif
 
-#define __TVOS_9_0        90000
-#define __TVOS_9_1        90100
-#define __TVOS_9_2        90200
-#define __TVOS_10_0      100000
-#define __TVOS_10_0_1    100001
-#define __TVOS_10_1      100100
-#define __TVOS_10_2      100200
-#define __TVOS_11_0      110000
-#define __TVOS_11_1      110100
-#define __TVOS_11_2      110200
-#define __TVOS_11_3      110300
-#define __TVOS_11_4      110400
-#define __TVOS_12_0      120000
-#define __TVOS_12_1      120100
-#define __TVOS_12_2      120200
-#define __TVOS_12_3      120300
-#define __TVOS_13_0      130000
-#define __TVOS_13_2      130200
-#define __TVOS_13_3      130300
-#define __TVOS_13_4      130400
+#ifndef __API_TO_BE_DEPRECATED_TVOS
+#define __API_TO_BE_DEPRECATED_TVOS 100000
+#endif
 
-#define __WATCHOS_1_0     10000
-#define __WATCHOS_2_0     20000
-#define __WATCHOS_2_1     20100
-#define __WATCHOS_2_2     20200
-#define __WATCHOS_3_0     30000
-#define __WATCHOS_3_1     30100
-#define __WATCHOS_3_1_1   30101
-#define __WATCHOS_3_2     30200
-#define __WATCHOS_4_0     40000
-#define __WATCHOS_4_1     40100
-#define __WATCHOS_4_2     40200
-#define __WATCHOS_4_3     40300
-#define __WATCHOS_5_0     50000
-#define __WATCHOS_5_1     50100
-#define __WATCHOS_5_2     50200
-#define __WATCHOS_6_0     60000
-#define __WATCHOS_6_1     60100
-#define __WATCHOS_6_2     60200
+#ifndef __API_TO_BE_DEPRECATED_WATCHOS
+#define __API_TO_BE_DEPRECATED_WATCHOS 100000
+#endif
 
-#define __DRIVERKIT_19_0 190000
-#endif /* __MAC_10_0 */
+#ifndef __API_TO_BE_DEPRECATED_BRIDGEOS
 
+#endif
+
+#ifndef __API_TO_BE_DEPRECATED_MACCATALYST
+#define __API_TO_BE_DEPRECATED_MACCATALYST 100000
+#endif
+
+#ifndef __API_TO_BE_DEPRECATED_DRIVERKIT
+#define __API_TO_BE_DEPRECATED_DRIVERKIT 100000
+#endif
+
+
+
+#include <AvailabilityVersions.h>
 #include <AvailabilityInternal.h>
 
 #ifdef __IPHONE_OS_VERSION_MIN_REQUIRED
@@ -454,6 +361,8 @@
 #endif
 
 
+
+
 /* for use marking APIs unavailable for swift */
 #if defined(__has_feature)
   #if __has_feature(attribute_availability_swift)
@@ -501,9 +410,9 @@
      *    __API_AVAILABLE(macos(10.4), ios(8.0), watchos(2.0), tvos(10.0))
      *    __API_AVAILABLE(driverkit(19.0))
      */
-    #define __API_AVAILABLE(...) __API_AVAILABLE_GET_MACRO(__VA_ARGS__,__API_AVAILABLE7, __API_AVAILABLE6, __API_AVAILABLE5, __API_AVAILABLE4, __API_AVAILABLE3, __API_AVAILABLE2, __API_AVAILABLE1, 0)(__VA_ARGS__)
+    #define __API_AVAILABLE(...) __API_AVAILABLE_GET_MACRO(__VA_ARGS__,__API_AVAILABLE8, __API_AVAILABLE7, __API_AVAILABLE6, __API_AVAILABLE5, __API_AVAILABLE4, __API_AVAILABLE3, __API_AVAILABLE2, __API_AVAILABLE1, 0)(__VA_ARGS__)
     
-    #define __API_AVAILABLE_BEGIN(...) _Pragma("clang attribute push") __API_AVAILABLE_BEGIN_GET_MACRO(__VA_ARGS__,__API_AVAILABLE_BEGIN7, __API_AVAILABLE_BEGIN6, __API_AVAILABLE_BEGIN5, __API_AVAILABLE_BEGIN4, __API_AVAILABLE_BEGIN3, __API_AVAILABLE_BEGIN2, __API_AVAILABLE_BEGIN1, 0)(__VA_ARGS__)
+    #define __API_AVAILABLE_BEGIN(...) _Pragma("clang attribute push") __API_AVAILABLE_BEGIN_GET_MACRO(__VA_ARGS__,__API_AVAILABLE_BEGIN8, __API_AVAILABLE_BEGIN7, __API_AVAILABLE_BEGIN6, __API_AVAILABLE_BEGIN5, __API_AVAILABLE_BEGIN4, __API_AVAILABLE_BEGIN3, __API_AVAILABLE_BEGIN2, __API_AVAILABLE_BEGIN1, 0)(__VA_ARGS__)
     #define __API_AVAILABLE_END _Pragma("clang attribute pop")
 
     /*
@@ -522,13 +431,13 @@
      *    __API_DEPRECATED_WITH_REPLACEMENT("-setName:", tvos(10.0, 10.4), ios(9.0, 10.0))
      *    __API_DEPRECATED_WITH_REPLACEMENT("SomeClassName", macos(10.4, 10.6), watchos(2.0, 3.0))
      */
-    #define __API_DEPRECATED(...) __API_DEPRECATED_MSG_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_MSG8,__API_DEPRECATED_MSG7,__API_DEPRECATED_MSG6,__API_DEPRECATED_MSG5,__API_DEPRECATED_MSG4,__API_DEPRECATED_MSG3,__API_DEPRECATED_MSG2,__API_DEPRECATED_MSG1, 0)(__VA_ARGS__)
-    #define __API_DEPRECATED_WITH_REPLACEMENT(...) __API_DEPRECATED_REP_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_REP8,__API_DEPRECATED_REP7,__API_DEPRECATED_REP6,__API_DEPRECATED_REP5,__API_DEPRECATED_REP4,__API_DEPRECATED_REP3,__API_DEPRECATED_REP2,__API_DEPRECATED_REP1, 0)(__VA_ARGS__)
+    #define __API_DEPRECATED(...) __API_DEPRECATED_MSG_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_MSG9, __API_DEPRECATED_MSG8,__API_DEPRECATED_MSG7,__API_DEPRECATED_MSG6,__API_DEPRECATED_MSG5,__API_DEPRECATED_MSG4,__API_DEPRECATED_MSG3,__API_DEPRECATED_MSG2,__API_DEPRECATED_MSG1, 0)(__VA_ARGS__)
+    #define __API_DEPRECATED_WITH_REPLACEMENT(...) __API_DEPRECATED_REP_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_REP9,__API_DEPRECATED_REP8,__API_DEPRECATED_REP7,__API_DEPRECATED_REP6,__API_DEPRECATED_REP5,__API_DEPRECATED_REP4,__API_DEPRECATED_REP3,__API_DEPRECATED_REP2,__API_DEPRECATED_REP1, 0)(__VA_ARGS__)
 
-    #define __API_DEPRECATED_BEGIN(...) _Pragma("clang attribute push") __API_DEPRECATED_BEGIN_MSG_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_BEGIN_MSG8,__API_DEPRECATED_BEGIN_MSG7, __API_DEPRECATED_BEGIN_MSG6, __API_DEPRECATED_BEGIN_MSG5, __API_DEPRECATED_BEGIN_MSG4, __API_DEPRECATED_BEGIN_MSG3, __API_DEPRECATED_BEGIN_MSG2, __API_DEPRECATED_BEGIN_MSG1, 0)(__VA_ARGS__)
+    #define __API_DEPRECATED_BEGIN(...) _Pragma("clang attribute push") __API_DEPRECATED_BEGIN_MSG_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_BEGIN_MSG9, __API_DEPRECATED_BEGIN_MSG8,__API_DEPRECATED_BEGIN_MSG7, __API_DEPRECATED_BEGIN_MSG6, __API_DEPRECATED_BEGIN_MSG5, __API_DEPRECATED_BEGIN_MSG4, __API_DEPRECATED_BEGIN_MSG3, __API_DEPRECATED_BEGIN_MSG2, __API_DEPRECATED_BEGIN_MSG1, 0)(__VA_ARGS__)
     #define __API_DEPRECATED_END _Pragma("clang attribute pop")
 
-    #define __API_DEPRECATED_WITH_REPLACEMENT_BEGIN(...) _Pragma("clang attribute push") __API_DEPRECATED_BEGIN_REP_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_BEGIN_REP8,__API_DEPRECATED_BEGIN_REP7, __API_DEPRECATED_BEGIN_REP6, __API_DEPRECATED_BEGIN_REP5, __API_DEPRECATED_BEGIN_REP4, __API_DEPRECATED_BEGIN_REP3, __API_DEPRECATED_BEGIN_REP2, __API_DEPRECATED_BEGIN_REP1, 0)(__VA_ARGS__)
+    #define __API_DEPRECATED_WITH_REPLACEMENT_BEGIN(...) _Pragma("clang attribute push") __API_DEPRECATED_BEGIN_REP_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_BEGIN_REP9, __API_DEPRECATED_BEGIN_REP8,__API_DEPRECATED_BEGIN_REP7, __API_DEPRECATED_BEGIN_REP6, __API_DEPRECATED_BEGIN_REP5, __API_DEPRECATED_BEGIN_REP4, __API_DEPRECATED_BEGIN_REP3, __API_DEPRECATED_BEGIN_REP2, __API_DEPRECATED_BEGIN_REP1, 0)(__VA_ARGS__)
     #define __API_DEPRECATED_WITH_REPLACEMENT_END _Pragma("clang attribute pop")
 
     /*
@@ -539,9 +448,9 @@
      *    __API_UNAVAILABLE(macos)
      *    __API_UNAVAILABLE(watchos, tvos)
      */
-    #define __API_UNAVAILABLE(...) __API_UNAVAILABLE_GET_MACRO(__VA_ARGS__,__API_UNAVAILABLE7,__API_UNAVAILABLE6,__API_UNAVAILABLE5,__API_UNAVAILABLE4,__API_UNAVAILABLE3,__API_UNAVAILABLE2,__API_UNAVAILABLE1, 0)(__VA_ARGS__)
+    #define __API_UNAVAILABLE(...) __API_UNAVAILABLE_GET_MACRO(__VA_ARGS__,__API_UNAVAILABLE8,__API_UNAVAILABLE7,__API_UNAVAILABLE6,__API_UNAVAILABLE5,__API_UNAVAILABLE4,__API_UNAVAILABLE3,__API_UNAVAILABLE2,__API_UNAVAILABLE1, 0)(__VA_ARGS__)
 
-    #define __API_UNAVAILABLE_BEGIN(...) _Pragma("clang attribute push") __API_UNAVAILABLE_BEGIN_GET_MACRO(__VA_ARGS__,__API_UNAVAILABLE_BEGIN7,__API_UNAVAILABLE_BEGIN6, __API_UNAVAILABLE_BEGIN5, __API_UNAVAILABLE_BEGIN4, __API_UNAVAILABLE_BEGIN3, __API_UNAVAILABLE_BEGIN2, __API_UNAVAILABLE_BEGIN1, 0)(__VA_ARGS__)
+    #define __API_UNAVAILABLE_BEGIN(...) _Pragma("clang attribute push") __API_UNAVAILABLE_BEGIN_GET_MACRO(__VA_ARGS__,__API_UNAVAILABLE_BEGIN8,__API_UNAVAILABLE_BEGIN7,__API_UNAVAILABLE_BEGIN6, __API_UNAVAILABLE_BEGIN5, __API_UNAVAILABLE_BEGIN4, __API_UNAVAILABLE_BEGIN3, __API_UNAVAILABLE_BEGIN2, __API_UNAVAILABLE_BEGIN1, 0)(__VA_ARGS__)
     #define __API_UNAVAILABLE_END _Pragma("clang attribute pop")
  #else 
 
diff --git a/lib/libc/include/x86_64-macos.10-none/AvailabilityInternal.h b/lib/libc/include/any-macos.13-any/AvailabilityInternal.h
similarity index 99%
rename from lib/libc/include/x86_64-macos.10-none/AvailabilityInternal.h
rename to lib/libc/include/any-macos.13-any/AvailabilityInternal.h
index 11e6d1ed17..4e1e72d8e8 100644
--- a/lib/libc/include/x86_64-macos.10-none/AvailabilityInternal.h
+++ b/lib/libc/include/any-macos.13-any/AvailabilityInternal.h
@@ -45,6 +45,9 @@
     #ifdef __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__
         /* compiler sets __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ when -miphoneos-version-min is used */
         #define __IPHONE_OS_VERSION_MIN_REQUIRED __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__
+    /* set to 1 when RC_FALLBACK_PLATFORM=iphoneos */
+    #elif 0
+        #define __IPHONE_OS_VERSION_MIN_REQUIRED 0
     #endif
 #endif /* __IPHONE_OS_VERSION_MIN_REQUIRED */
 
@@ -52,7 +55,7 @@
     #ifdef __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__
         /* compiler sets __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ when -mtvos-version-min is used */
         #define __TV_OS_VERSION_MIN_REQUIRED __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__
-        #define __TV_OS_VERSION_MAX_ALLOWED __TVOS_13_0 
+        #define __TV_OS_VERSION_MAX_ALLOWED __TVOS_16_1
         /* for compatibility with existing code.  New code should use platform specific checks */
         #define __IPHONE_OS_VERSION_MIN_REQUIRED 90000
     #endif
@@ -62,7 +65,7 @@
     #ifdef __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__
         /* compiler sets __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ when -mwatchos-version-min is used */
         #define __WATCH_OS_VERSION_MIN_REQUIRED __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__
-        #define __WATCH_OS_VERSION_MAX_ALLOWED 60000
+        #define __WATCH_OS_VERSION_MAX_ALLOWED __WATCHOS_9_1
         /* for compatibility with existing code.  New code should use platform specific checks */
         #define __IPHONE_OS_VERSION_MIN_REQUIRED 90000
     #endif
@@ -72,7 +75,7 @@
     #ifdef __ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__
         
         #define __BRIDGE_OS_VERSION_MIN_REQUIRED __ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__
-        #define __BRIDGE_OS_VERSION_MAX_ALLOWED 20000
+        #define __BRIDGE_OS_VERSION_MAX_ALLOWED 70100
         /* for compatibility with existing code.  New code should use platform specific checks */
         #define __IPHONE_OS_VERSION_MIN_REQUIRED 110000
     #endif
@@ -87,14 +90,14 @@
 #ifdef __MAC_OS_X_VERSION_MIN_REQUIRED
     /* make sure a default max version is set */
     #ifndef __MAC_OS_X_VERSION_MAX_ALLOWED
-        #define __MAC_OS_X_VERSION_MAX_ALLOWED __MAC_10_15
+        #define __MAC_OS_X_VERSION_MAX_ALLOWED __MAC_13_0
     #endif
 #endif /* __MAC_OS_X_VERSION_MIN_REQUIRED */
 
 #ifdef __IPHONE_OS_VERSION_MIN_REQUIRED
     /* make sure a default max version is set */
     #ifndef __IPHONE_OS_VERSION_MAX_ALLOWED
-        #define __IPHONE_OS_VERSION_MAX_ALLOWED     __IPHONE_13_0
+        #define __IPHONE_OS_VERSION_MAX_ALLOWED     __IPHONE_16_1
     #endif
     /* make sure a valid min is set */
     #if __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_2_0
@@ -2887,7 +2890,7 @@
                #if __has_builtin(__is_target_environment)
                 #if __has_builtin(__is_target_variant_os)
                  #if __has_builtin(__is_target_variant_environment)
-                  #if (__is_target_arch(x86_64) && __is_target_vendor(apple) && __is_target_os(ios) && __is_target_environment(macabi))
+                  #if ((__is_target_arch(x86_64) || __is_target_arch(arm64) || __is_target_arch(arm64e)) && __is_target_vendor(apple) && __is_target_os(ios) && __is_target_environment(macabi))
                     #define __AVAILABILITY_INTERNAL__IPHONE_COMPAT_VERSION __attribute__((availability(ios,introduced=4.0)))
                     #define __AVAILABILITY_INTERNAL__IPHONE_COMPAT_VERSION_DEP__IPHONE_COMPAT_VERSION               __attribute__((availability(ios,unavailable)))
                     #define __AVAILABILITY_INTERNAL__IPHONE_COMPAT_VERSION_DEP__IPHONE_COMPAT_VERSION_MSG(_msg)     __attribute__((availability(ios,unavailable)))
@@ -4452,6 +4455,7 @@
     #endif
     #define __API_AVAILABLE_PLATFORM_driverkit(x) driverkit,introduced=x
 
+
     #if defined(__has_attribute)
       #if __has_attribute(availability)
         #define __API_A(x) __attribute__((availability(__API_AVAILABLE_PLATFORM_##x)))
@@ -4469,7 +4473,8 @@
     #define __API_AVAILABLE5(x,y,z,t,b) __API_A(x) __API_A(y) __API_A(z) __API_A(t) __API_A(b)
     #define __API_AVAILABLE6(x,y,z,t,b,m) __API_A(x) __API_A(y) __API_A(z) __API_A(t) __API_A(b) __API_A(m)
     #define __API_AVAILABLE7(x,y,z,t,b,m,d) __API_A(x) __API_A(y) __API_A(z) __API_A(t) __API_A(b) __API_A(m) __API_A(d)
-    #define __API_AVAILABLE_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,NAME,...) NAME
+    #define __API_AVAILABLE8(x,y,z,t,b,m,d,l) __API_A(x) __API_A(y) __API_A(z) __API_A(t) __API_A(b) __API_A(m) __API_A(d) __API_A(l)
+    #define __API_AVAILABLE_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME
 
     #define __API_APPLY_TO any(record, enum, enum_constant, function, objc_method, objc_category, objc_protocol, objc_interface, objc_property, type_alias, variable, field)
     #define __API_RANGE_STRINGIFY(x) __API_RANGE_STRINGIFY2(x)
@@ -4484,7 +4489,8 @@
     #define __API_AVAILABLE_BEGIN5(a,b,c,d,e) __API_A_BEGIN(a) __API_A_BEGIN(b) __API_A_BEGIN(c) __API_A_BEGIN(d) __API_A_BEGIN(e)
     #define __API_AVAILABLE_BEGIN6(a,b,c,d,e,f) __API_A_BEGIN(a) __API_A_BEGIN(b) __API_A_BEGIN(c) __API_A_BEGIN(d) __API_A_BEGIN(e) __API_A_BEGIN(f)
     #define __API_AVAILABLE_BEGIN7(a,b,c,d,e,f,g) __API_A_BEGIN(a) __API_A_BEGIN(b) __API_A_BEGIN(c) __API_A_BEGIN(d) __API_A_BEGIN(e) __API_A_BEGIN(f) __API_A_BEGIN(g)
-    #define __API_AVAILABLE_BEGIN_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,NAME,...) NAME
+    #define __API_AVAILABLE_BEGIN8(a,b,c,d,e,f,g,h) __API_A_BEGIN(a) __API_A_BEGIN(b) __API_A_BEGIN(c) __API_A_BEGIN(d) __API_A_BEGIN(e) __API_A_BEGIN(f) __API_A_BEGIN(g) __API_A_BEGIN(h)
+    #define __API_AVAILABLE_BEGIN_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME
 
     
     #define __API_DEPRECATED_PLATFORM_macos(x,y) macos,introduced=x,deprecated=y
@@ -4500,6 +4506,7 @@
     #endif
     #define __API_DEPRECATED_PLATFORM_driverkit(x,y) driverkit,introduced=x,deprecated=y
 
+
     #if defined(__has_attribute)
       #if __has_attribute(availability)
         #define __API_D(msg,x) __attribute__((availability(__API_DEPRECATED_PLATFORM_##x,message=msg)))
@@ -4517,7 +4524,8 @@
     #define __API_DEPRECATED_MSG6(msg,x,y,z,t,b) __API_DEPRECATED_MSG5(msg,x,y,z,t) __API_D(msg,b)
     #define __API_DEPRECATED_MSG7(msg,x,y,z,t,b,m) __API_DEPRECATED_MSG6(msg,x,y,z,t,b) __API_D(msg,m)
     #define __API_DEPRECATED_MSG8(msg,x,y,z,t,b,m,d) __API_DEPRECATED_MSG7(msg,x,y,z,t,b,m) __API_D(msg,d)
-    #define __API_DEPRECATED_MSG_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME
+    #define __API_DEPRECATED_MSG9(msg,x,y,z,t,b,m,d,l) __API_DEPRECATED_MSG8(msg,x,y,z,t,b,m,d) __API_D(msg,l)
+    #define __API_DEPRECATED_MSG_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME
 
     #define __API_D_BEGIN(msg, x) _Pragma(__API_RANGE_STRINGIFY (clang attribute (__attribute__((availability(__API_DEPRECATED_PLATFORM_##x,message=msg))), apply_to = __API_APPLY_TO)))
 
@@ -4528,7 +4536,8 @@
     #define __API_DEPRECATED_BEGIN_MSG6(msg,a,b,c,d,e) __API_D_BEGIN(msg,a) __API_D_BEGIN(msg,b) __API_D_BEGIN(msg,c) __API_D_BEGIN(msg,d) __API_D_BEGIN(msg,e)
     #define __API_DEPRECATED_BEGIN_MSG7(msg,a,b,c,d,e,f) __API_D_BEGIN(msg,a) __API_D_BEGIN(msg,b) __API_D_BEGIN(msg,c) __API_D_BEGIN(msg,d) __API_D_BEGIN(msg,e) __API_D_BEGIN(msg,f)
     #define __API_DEPRECATED_BEGIN_MSG8(msg,a,b,c,d,e,f,g) __API_D_BEGIN(msg,a) __API_D_BEGIN(msg,b) __API_D_BEGIN(msg,c) __API_D_BEGIN(msg,d) __API_D_BEGIN(msg,e) __API_D_BEGIN(msg,f) __API_D_BEGIN(msg,g)
-    #define __API_DEPRECATED_BEGIN_MSG_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME
+    #define __API_DEPRECATED_BEGIN_MSG9(msg,a,b,c,d,e,f,g,h) __API_D_BEGIN(msg,a) __API_D_BEGIN(msg,b) __API_D_BEGIN(msg,c) __API_D_BEGIN(msg,d) __API_D_BEGIN(msg,e) __API_D_BEGIN(msg,f) __API_D_BEGIN(msg,g) __API_D_BEGIN(msg,h)
+    #define __API_DEPRECATED_BEGIN_MSG_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME
 
     #if __has_feature(attribute_availability_with_replacement)
         #define __API_R(rep,x) __attribute__((availability(__API_DEPRECATED_PLATFORM_##x,replacement=rep)))
@@ -4543,7 +4552,8 @@
     #define __API_DEPRECATED_REP6(rep,x,y,z,t,b) __API_DEPRECATED_REP5(rep,x,y,z,t) __API_R(rep,b)
     #define __API_DEPRECATED_REP7(rep,x,y,z,t,b,m) __API_DEPRECATED_REP6(rep,x,y,z,t,b) __API_R(rep,m)
     #define __API_DEPRECATED_REP8(rep,x,y,z,t,b,m,d) __API_DEPRECATED_REP7(rep,x,y,z,t,b,m) __API_R(rep,d)
-    #define __API_DEPRECATED_REP_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME
+    #define __API_DEPRECATED_REP9(rep,x,y,z,t,b,m,d,l) __API_DEPRECATED_REP8(rep,x,y,z,t,b,m,d) __API_R(rep,l)
+    #define __API_DEPRECATED_REP_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME
 
     #if __has_feature(attribute_availability_with_replacement)
         #define __API_R_BEGIN(rep,x) _Pragma(__API_RANGE_STRINGIFY (clang attribute (__attribute__((availability(__API_DEPRECATED_PLATFORM_##x,replacement=rep))), apply_to = __API_APPLY_TO)))    
@@ -4558,7 +4568,9 @@
     #define __API_DEPRECATED_BEGIN_REP6(rep,a,b,c,d,e) __API_R_BEGIN(rep,a) __API_R_BEGIN(rep,b) __API_R_BEGIN(rep,c) __API_R_BEGIN(rep,d) __API_R_BEGIN(rep,e)
     #define __API_DEPRECATED_BEGIN_REP7(rep,a,b,c,d,e,f) __API_R_BEGIN(rep,a) __API_R_BEGIN(rep,b) __API_R_BEGIN(rep,c) __API_R_BEGIN(rep,d) __API_R_BEGIN(rep,e) __API_R_BEGIN(rep,f)
     #define __API_DEPRECATED_BEGIN_REP8(rep,a,b,c,d,e,f,g) __API_R_BEGIN(rep,a) __API_R_BEGIN(rep,b) __API_R_BEGIN(rep,c) __API_R_BEGIN(rep,d) __API_R_BEGIN(rep,e) __API_R_BEGIN(rep,f) __API_R_BEGIN(rep,g)
-    #define __API_DEPRECATED_BEGIN_REP_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME
+    #define __API_DEPRECATED_BEGIN_REP9(rep,a,b,c,d,e,f,g,h) __API_R_BEGIN(rep,a) __API_R_BEGIN(rep,b) __API_R_BEGIN(rep,c) __API_R_BEGIN(rep,d) __API_R_BEGIN(rep,e) __API_R_BEGIN(rep,f) __API_R_BEGIN(rep,g) __API_R_BEGIN(rep,h)
+
+    #define __API_DEPRECATED_BEGIN_REP_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME
 
     /*
      * API Unavailability
@@ -4581,6 +4593,7 @@
     #endif
     #define __API_UNAVAILABLE_PLATFORM_driverkit driverkit,unavailable
 
+
     #if defined(__has_attribute)
       #if __has_attribute(availability)
         #define __API_U(x) __attribute__((availability(__API_UNAVAILABLE_PLATFORM_##x)))
@@ -4598,7 +4611,8 @@
     #define __API_UNAVAILABLE5(x,y,z,t,b) __API_UNAVAILABLE4(x,y,z,t) __API_U(b)
     #define __API_UNAVAILABLE6(x,y,z,t,b,m) __API_UNAVAILABLE5(x,y,z,t,b) __API_U(m)
     #define __API_UNAVAILABLE7(x,y,z,t,b,m,d) __API_UNAVAILABLE6(x,y,z,t,b,m) __API_U(d)
-    #define __API_UNAVAILABLE_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,NAME,...) NAME
+    #define __API_UNAVAILABLE8(x,y,z,t,b,m,d,l) __API_UNAVAILABLE7(x,y,z,t,b,m,d) __API_U(l)
+    #define __API_UNAVAILABLE_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME
 
     #define __API_U_BEGIN(x) _Pragma(__API_RANGE_STRINGIFY (clang attribute (__attribute__((availability(__API_UNAVAILABLE_PLATFORM_##x))), apply_to = __API_APPLY_TO)))
 
@@ -4608,8 +4622,9 @@
     #define __API_UNAVAILABLE_BEGIN4(a,b,c,d) __API_U_BEGIN(a) __API_U_BEGIN(b) __API_U_BEGIN(c) __API_U_BEGIN(d)
     #define __API_UNAVAILABLE_BEGIN5(a,b,c,d,e) __API_U_BEGIN(a) __API_U_BEGIN(b) __API_U_BEGIN(c) __API_U_BEGIN(d) __API_U_BEGIN(e)
     #define __API_UNAVAILABLE_BEGIN6(a,b,c,d,e,f) __API_U_BEGIN(a) __API_U_BEGIN(b) __API_U_BEGIN(c) __API_U_BEGIN(d) __API_U_BEGIN(e) __API_U_BEGIN(f)
-    #define __API_UNAVAILABLE_BEGIN7(a,b,c,d,e,f) __API_U_BEGIN(a) __API_U_BEGIN(b) __API_U_BEGIN(c) __API_U_BEGIN(d) __API_U_BEGIN(e) __API_U_BEGIN(f) __API_U_BEGIN(g)
-    #define __API_UNAVAILABLE_BEGIN_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,NAME,...) NAME
+    #define __API_UNAVAILABLE_BEGIN7(a,b,c,d,e,f,g) __API_U_BEGIN(a) __API_U_BEGIN(b) __API_U_BEGIN(c) __API_U_BEGIN(d) __API_U_BEGIN(e) __API_U_BEGIN(f) __API_U_BEGIN(g)
+    #define __API_UNAVAILABLE_BEGIN8(a,b,c,d,e,f,g,h) __API_U_BEGIN(a) __API_U_BEGIN(b) __API_U_BEGIN(c) __API_U_BEGIN(d) __API_U_BEGIN(e) __API_U_BEGIN(f) __API_U_BEGIN(g) __API_U_BEGIN(h)
+    #define __API_UNAVAILABLE_BEGIN_GET_MACRO(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME
  #else 
 
  /* 
@@ -4643,7 +4658,7 @@
 
 /*
  * Swift compiler version
- * Allows for project-agnostic “epochs” for frameworks imported into Swift via the Clang importer, like #if _compiler_version for Swift
+ * Allows for project-agnostic "epochs" for frameworks imported into Swift via the Clang importer, like #if _compiler_version for Swift
  * Example:
  *
  *  #if __swift_compiler_version_at_least(800, 2, 20)
diff --git a/lib/libc/include/x86_64-macos.10-none/AvailabilityMacros.h b/lib/libc/include/any-macos.13-any/AvailabilityMacros.h
similarity index 99%
rename from lib/libc/include/x86_64-macos.10-none/AvailabilityMacros.h
rename to lib/libc/include/any-macos.13-any/AvailabilityMacros.h
index 9cc7100ffe..313d37c4cc 100644
--- a/lib/libc/include/x86_64-macos.10-none/AvailabilityMacros.h
+++ b/lib/libc/include/any-macos.13-any/AvailabilityMacros.h
@@ -117,9 +117,14 @@
 #define MAC_OS_X_VERSION_10_14_1    101401
 #define MAC_OS_X_VERSION_10_14_4    101404
 #define MAC_OS_X_VERSION_10_15      101500
-#define MAC_OS_X_VERSION_10_15_1    101501
+#define MAC_OS_VERSION_11_0         110000
+#define MAC_OS_VERSION_11_1         110100
+#define MAC_OS_VERSION_11_3         110300
+#define MAC_OS_VERSION_12_0         120000
+#define MAC_OS_VERSION_13_0         130000
+#define MAC_OS_VERSION_13_1         130100
 
-/*
+/* 
  * If min OS not specified, assume 10.4 for intel
  * Note: compiler driver may set _ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED_ based on MACOSX_DEPLOYMENT_TARGET environment variable
  */
@@ -144,10 +149,10 @@
  * if max OS not specified, assume larger of (10.15, min)
  */
 #ifndef MAC_OS_X_VERSION_MAX_ALLOWED
-    #if MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_15
+    #if MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_VERSION_13_1
         #define MAC_OS_X_VERSION_MAX_ALLOWED MAC_OS_X_VERSION_MIN_REQUIRED
     #else
-        #define MAC_OS_X_VERSION_MAX_ALLOWED MAC_OS_X_VERSION_10_15
+        #define MAC_OS_X_VERSION_MAX_ALLOWED MAC_OS_VERSION_13_1
     #endif
 #endif
 
diff --git a/lib/libc/include/any-macos.13-any/AvailabilityVersions.h b/lib/libc/include/any-macos.13-any/AvailabilityVersions.h
new file mode 100644
index 0000000000..f889a84b18
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/AvailabilityVersions.h
@@ -0,0 +1,255 @@
+/*
+ * Copyright (c) 2019 by Apple Inc.. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ * 
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ * 
+ * @APPLE_LICENSE_HEADER_END@
+ */
+ 
+#ifndef __AVAILABILITY_VERSIONS__
+#define __AVAILABILITY_VERSIONS__
+
+#define __MAC_10_0            1000
+#define __MAC_10_1            1010
+#define __MAC_10_2            1020
+#define __MAC_10_3            1030
+#define __MAC_10_4            1040
+#define __MAC_10_5            1050
+#define __MAC_10_6            1060
+#define __MAC_10_7            1070
+#define __MAC_10_8            1080
+#define __MAC_10_9            1090
+#define __MAC_10_10         101000
+#define __MAC_10_10_2       101002
+#define __MAC_10_10_3       101003
+#define __MAC_10_11         101100
+#define __MAC_10_11_2       101102
+#define __MAC_10_11_3       101103
+#define __MAC_10_11_4       101104
+#define __MAC_10_12         101200
+#define __MAC_10_12_1       101201
+#define __MAC_10_12_2       101202
+#define __MAC_10_12_4       101204
+#define __MAC_10_13         101300
+#define __MAC_10_13_1       101301
+#define __MAC_10_13_2       101302
+#define __MAC_10_13_4       101304
+#define __MAC_10_14         101400
+#define __MAC_10_14_1       101401
+#define __MAC_10_14_4       101404
+#define __MAC_10_14_6       101406
+#define __MAC_10_15         101500
+#define __MAC_10_15_1       101501
+#define __MAC_10_15_4       101504
+#define __MAC_10_16         101600
+#define __MAC_11_0          110000
+#define __MAC_11_1          110100
+#define __MAC_11_3          110300
+#define __MAC_11_4          110400
+#define __MAC_11_5          110500
+#define __MAC_11_6          110600
+#define __MAC_12_0          120000
+#define __MAC_12_1          120100
+#define __MAC_12_2          120200
+#define __MAC_12_3          120300
+#define __MAC_13_0          130000
+/* __MAC_NA is not defined to a value but is used as a token by macros to indicate that the API is unavailable */
+
+#define __IPHONE_2_0      20000
+#define __IPHONE_2_1      20100
+#define __IPHONE_2_2      20200
+#define __IPHONE_3_0      30000
+#define __IPHONE_3_1      30100
+#define __IPHONE_3_2      30200
+#define __IPHONE_4_0      40000
+#define __IPHONE_4_1      40100
+#define __IPHONE_4_2      40200
+#define __IPHONE_4_3      40300
+#define __IPHONE_5_0      50000
+#define __IPHONE_5_1      50100
+#define __IPHONE_6_0      60000
+#define __IPHONE_6_1      60100
+#define __IPHONE_7_0      70000
+#define __IPHONE_7_1      70100
+#define __IPHONE_8_0      80000
+#define __IPHONE_8_1      80100
+#define __IPHONE_8_2      80200
+#define __IPHONE_8_3      80300
+#define __IPHONE_8_4      80400
+#define __IPHONE_9_0      90000
+#define __IPHONE_9_1      90100
+#define __IPHONE_9_2      90200
+#define __IPHONE_9_3      90300
+#define __IPHONE_10_0    100000
+#define __IPHONE_10_1    100100
+#define __IPHONE_10_2    100200
+#define __IPHONE_10_3    100300
+#define __IPHONE_11_0    110000
+#define __IPHONE_11_1    110100
+#define __IPHONE_11_2    110200
+#define __IPHONE_11_3    110300
+#define __IPHONE_11_4    110400
+#define __IPHONE_12_0    120000
+#define __IPHONE_12_1    120100
+#define __IPHONE_12_2    120200
+#define __IPHONE_12_3    120300
+#define __IPHONE_12_4    120400
+#define __IPHONE_13_0    130000
+#define __IPHONE_13_1    130100
+#define __IPHONE_13_2    130200
+#define __IPHONE_13_3    130300
+#define __IPHONE_13_4    130400
+#define __IPHONE_13_5    130500
+#define __IPHONE_13_6    130600
+#define __IPHONE_13_7    130700
+#define __IPHONE_14_0    140000
+#define __IPHONE_14_1    140100
+#define __IPHONE_14_2    140200
+#define __IPHONE_14_3    140300
+#define __IPHONE_14_5    140500
+#define __IPHONE_14_6    140600
+#define __IPHONE_14_7    140700
+#define __IPHONE_14_8    140800
+#define __IPHONE_15_0    150000
+#define __IPHONE_15_1    150100
+#define __IPHONE_15_2    150200
+#define __IPHONE_15_3    150300
+#define __IPHONE_15_4    150400
+#define __IPHONE_16_0    160000
+#define __IPHONE_16_1    160100
+/* __IPHONE_NA is not defined to a value but is used as a token by macros to indicate that the API is unavailable */
+
+#define __TVOS_9_0        90000
+#define __TVOS_9_1        90100
+#define __TVOS_9_2        90200
+#define __TVOS_10_0      100000
+#define __TVOS_10_0_1    100001
+#define __TVOS_10_1      100100
+#define __TVOS_10_2      100200
+#define __TVOS_11_0      110000
+#define __TVOS_11_1      110100
+#define __TVOS_11_2      110200
+#define __TVOS_11_3      110300
+#define __TVOS_11_4      110400
+#define __TVOS_12_0      120000
+#define __TVOS_12_1      120100
+#define __TVOS_12_2      120200
+#define __TVOS_12_3      120300
+#define __TVOS_12_4      120400
+#define __TVOS_13_0      130000
+#define __TVOS_13_2      130200
+#define __TVOS_13_3      130300
+#define __TVOS_13_4      130400
+#define __TVOS_14_0      140000
+#define __TVOS_14_1      140100
+#define __TVOS_14_2      140200
+#define __TVOS_14_3      140300
+#define __TVOS_14_5      140500
+#define __TVOS_14_6      140600
+#define __TVOS_14_7      140700
+#define __TVOS_15_0      150000
+#define __TVOS_15_1      150100
+#define __TVOS_15_2      150200
+#define __TVOS_15_3      150300
+#define __TVOS_15_4      150400
+#define __TVOS_16_0      160000
+#define __TVOS_16_1      160100
+
+#define __WATCHOS_1_0     10000
+#define __WATCHOS_2_0     20000
+#define __WATCHOS_2_1     20100
+#define __WATCHOS_2_2     20200
+#define __WATCHOS_3_0     30000
+#define __WATCHOS_3_1     30100
+#define __WATCHOS_3_1_1   30101
+#define __WATCHOS_3_2     30200
+#define __WATCHOS_4_0     40000
+#define __WATCHOS_4_1     40100
+#define __WATCHOS_4_2     40200
+#define __WATCHOS_4_3     40300
+#define __WATCHOS_5_0     50000
+#define __WATCHOS_5_1     50100
+#define __WATCHOS_5_2     50200
+#define __WATCHOS_5_3     50300
+#define __WATCHOS_6_0     60000
+#define __WATCHOS_6_1     60100
+#define __WATCHOS_6_2     60200
+#define __WATCHOS_7_0     70000
+#define __WATCHOS_7_1     70100
+#define __WATCHOS_7_2     70200
+#define __WATCHOS_7_3     70300
+#define __WATCHOS_7_4     70400
+#define __WATCHOS_7_5     70500
+#define __WATCHOS_7_6     70600
+#define __WATCHOS_8_0     80000
+#define __WATCHOS_8_1     80100
+#define __WATCHOS_8_3     80300
+#define __WATCHOS_8_4     80400
+#define __WATCHOS_8_5     80500
+#define __WATCHOS_9_0     90000
+#define __WATCHOS_9_1     90100
+
+/*
+ * Set up standard Mac OS X versions
+ */
+
+#if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || defined(_DARWIN_C_SOURCE)
+
+#define MAC_OS_X_VERSION_10_0         1000
+#define MAC_OS_X_VERSION_10_1         1010
+#define MAC_OS_X_VERSION_10_2         1020
+#define MAC_OS_X_VERSION_10_3         1030
+#define MAC_OS_X_VERSION_10_4         1040
+#define MAC_OS_X_VERSION_10_5         1050
+#define MAC_OS_X_VERSION_10_6         1060
+#define MAC_OS_X_VERSION_10_7         1070
+#define MAC_OS_X_VERSION_10_8         1080
+#define MAC_OS_X_VERSION_10_9         1090
+#define MAC_OS_X_VERSION_10_10      101000
+#define MAC_OS_X_VERSION_10_10_2    101002
+#define MAC_OS_X_VERSION_10_10_3    101003
+#define MAC_OS_X_VERSION_10_11      101100
+#define MAC_OS_X_VERSION_10_11_2    101102
+#define MAC_OS_X_VERSION_10_11_3    101103
+#define MAC_OS_X_VERSION_10_11_4    101104
+#define MAC_OS_X_VERSION_10_12      101200
+#define MAC_OS_X_VERSION_10_12_1    101201
+#define MAC_OS_X_VERSION_10_12_2    101202
+#define MAC_OS_X_VERSION_10_12_4    101204
+#define MAC_OS_X_VERSION_10_13      101300
+#define MAC_OS_X_VERSION_10_13_1    101301
+#define MAC_OS_X_VERSION_10_13_2    101302
+#define MAC_OS_X_VERSION_10_13_4    101304
+#define MAC_OS_X_VERSION_10_14      101400
+#define MAC_OS_X_VERSION_10_14_1    101401
+#define MAC_OS_X_VERSION_10_14_4    101404
+#define MAC_OS_X_VERSION_10_14_6    101406
+#define MAC_OS_X_VERSION_10_15      101500
+#define MAC_OS_X_VERSION_10_15_1    101501
+#define MAC_OS_X_VERSION_10_16      101600
+#define MAC_OS_VERSION_11_0         110000
+#define MAC_OS_VERSION_12_0         120000
+#define MAC_OS_VERSION_13_0         130000
+
+#endif /* #if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || defined(_DARWIN_C_SOURCE) */
+
+#define __DRIVERKIT_19_0 190000
+#define __DRIVERKIT_20_0 200000
+#define __DRIVERKIT_21_0 210000
+
+#endif /* __AVAILABILITY_VERSIONS__ */
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/Block.h b/lib/libc/include/any-macos.13-any/Block.h
new file mode 100644
index 0000000000..e381a9585f
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/Block.h
@@ -0,0 +1,65 @@
+/*
+ *  Block.h
+ *
+ * Copyright (c) 2008-2010 Apple Inc. All rights reserved.
+ *
+ * @APPLE_LLVM_LICENSE_HEADER@
+ *
+ */
+
+#ifndef _Block_H_
+#define _Block_H_
+
+#if !defined(BLOCK_EXPORT)
+#   if defined(__cplusplus)
+#       define BLOCK_EXPORT extern "C" 
+#   else
+#       define BLOCK_EXPORT extern
+#   endif
+#endif
+
+#include <Availability.h>
+#include <TargetConditionals.h>
+#include <sys/cdefs.h>
+
+#if __cplusplus
+extern "C" {
+#endif
+
+// Create a heap based copy of a Block or simply add a reference to an existing one.
+// This must be paired with Block_release to recover memory, even when running
+// under Objective-C Garbage Collection.
+BLOCK_EXPORT void *__single _Block_copy(const void *__single aBlock)
+    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
+
+// Lose the reference, and if heap based and last reference, recover the memory
+BLOCK_EXPORT void _Block_release(const void *__single aBlock)
+    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
+
+
+// Used by the compiler. Do not call this function yourself.
+BLOCK_EXPORT void _Block_object_assign(void *, const void *, const int)
+    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
+
+// Used by the compiler. Do not call this function yourself.
+BLOCK_EXPORT void _Block_object_dispose(const void *, const int)
+    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
+
+// Used by the compiler. Do not use these variables yourself.
+BLOCK_EXPORT void * _NSConcreteGlobalBlock[32]
+    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
+BLOCK_EXPORT void * _NSConcreteStackBlock[32]
+    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
+
+
+#if __cplusplus
+}
+#endif
+
+// Type correct macros
+
+#define Block_copy(...) ((__typeof(__VA_ARGS__))_Block_copy((const void *)(__VA_ARGS__)))
+#define Block_release(...) _Block_release((const void *)(__VA_ARGS__))
+
+
+#endif
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/copyfile.h b/lib/libc/include/any-macos.13-any/copyfile.h
new file mode 100644
index 0000000000..2d3bc9ccf8
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/copyfile.h
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2004-2021 Apple, Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ * 
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ * 
+ * @APPLE_LICENSE_HEADER_END@
+ */
+#ifndef _COPYFILE_H_ /* version 0.1 */
+#define _COPYFILE_H_
+
+/*
+ * This API facilitates the copying of files and their associated
+ * metadata.  There are several open source projects that need
+ * modifications to support preserving extended attributes and ACLs
+ * and this API collapses several hundred lines of modifications into
+ * one or two calls.
+ */
+
+/* private */
+#include <sys/cdefs.h>
+#include <stdint.h>
+
+__BEGIN_DECLS
+__ptrcheck_abi_assume_single()
+struct _copyfile_state;
+typedef struct _copyfile_state * copyfile_state_t;
+typedef uint32_t copyfile_flags_t;
+
+/* public */
+
+/* receives:
+ *   from	path to source file system object
+ *   to		path to destination file system object
+ *   state	opaque blob for future extensibility
+ *		Must be NULL in current implementation
+ *   flags	(described below)
+ * returns:
+ *   int	negative for error
+ */
+
+int copyfile(const char *__unsafe_indexable from, const char *__unsafe_indexable to, copyfile_state_t state, copyfile_flags_t flags);
+int fcopyfile(int from_fd, int to_fd, copyfile_state_t, copyfile_flags_t flags);
+
+int copyfile_state_free(copyfile_state_t);
+copyfile_state_t copyfile_state_alloc(void);
+
+
+int copyfile_state_get(copyfile_state_t s, uint32_t flag, void * dst);
+int copyfile_state_set(copyfile_state_t s, uint32_t flag, const void * src);
+
+typedef int (*copyfile_callback_t)(int, int, copyfile_state_t, const char *__unsafe_indexable, const char *__unsafe_indexable, void *);
+
+#define COPYFILE_STATE_SRC_FD		1
+#define COPYFILE_STATE_SRC_FILENAME	2
+#define COPYFILE_STATE_DST_FD		3
+#define COPYFILE_STATE_DST_FILENAME	4
+#define COPYFILE_STATE_QUARANTINE	5
+#define	COPYFILE_STATE_STATUS_CB	6
+#define	COPYFILE_STATE_STATUS_CTX	7
+#define	COPYFILE_STATE_COPIED		8
+#define	COPYFILE_STATE_XATTRNAME	9
+#define	COPYFILE_STATE_WAS_CLONED	10
+#define	COPYFILE_STATE_SRC_BSIZE	11
+#define	COPYFILE_STATE_DST_BSIZE	12
+#define	COPYFILE_STATE_BSIZE		13
+
+
+#define	COPYFILE_DISABLE_VAR	"COPYFILE_DISABLE"
+
+/* flags for copyfile */
+
+#define COPYFILE_ACL	    (1<<0)
+#define COPYFILE_STAT	    (1<<1)
+#define COPYFILE_XATTR	    (1<<2)
+#define COPYFILE_DATA	    (1<<3)
+
+#define COPYFILE_SECURITY   (COPYFILE_STAT | COPYFILE_ACL)
+#define COPYFILE_METADATA   (COPYFILE_SECURITY | COPYFILE_XATTR)
+#define COPYFILE_ALL	    (COPYFILE_METADATA | COPYFILE_DATA)
+
+#define	COPYFILE_RECURSIVE	(1<<15)	/* Descend into hierarchies */
+#define COPYFILE_CHECK		(1<<16) /* return flags for xattr or acls if set */
+#define COPYFILE_EXCL		(1<<17) /* fail if destination exists */
+#define COPYFILE_NOFOLLOW_SRC	(1<<18) /* don't follow if source is a symlink */
+#define COPYFILE_NOFOLLOW_DST	(1<<19) /* don't follow if dst is a symlink */
+#define COPYFILE_MOVE		(1<<20) /* unlink src after copy */
+#define COPYFILE_UNLINK		(1<<21) /* unlink dst before copy */
+#define COPYFILE_NOFOLLOW	(COPYFILE_NOFOLLOW_SRC | COPYFILE_NOFOLLOW_DST)
+
+#define COPYFILE_PACK		(1<<22)
+#define COPYFILE_UNPACK		(1<<23)
+
+#define COPYFILE_CLONE		(1<<24)
+#define COPYFILE_CLONE_FORCE	(1<<25)
+
+#define COPYFILE_RUN_IN_PLACE	(1<<26)
+
+#define COPYFILE_DATA_SPARSE	(1<<27)
+
+#define COPYFILE_PRESERVE_DST_TRACKED	(1<<28)
+
+#define COPYFILE_VERBOSE	(1<<30)
+
+#define	COPYFILE_RECURSE_ERROR	0
+#define	COPYFILE_RECURSE_FILE	1
+#define	COPYFILE_RECURSE_DIR	2
+#define	COPYFILE_RECURSE_DIR_CLEANUP	3
+#define	COPYFILE_COPY_DATA	4
+#define	COPYFILE_COPY_XATTR	5
+
+#define	COPYFILE_START		1
+#define	COPYFILE_FINISH		2
+#define	COPYFILE_ERR		3
+#define	COPYFILE_PROGRESS	4
+
+#define	COPYFILE_CONTINUE	0
+#define	COPYFILE_SKIP	1
+#define	COPYFILE_QUIT	2
+
+__END_DECLS
+
+#endif /* _COPYFILE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/dispatch/base.h b/lib/libc/include/any-macos.13-any/dispatch/base.h
similarity index 86%
rename from lib/libc/include/x86_64-macos.10-none/dispatch/base.h
rename to lib/libc/include/any-macos.13-any/dispatch/base.h
index 86ed15d144..58406b0dfb 100644
--- a/lib/libc/include/x86_64-macos.10-none/dispatch/base.h
+++ b/lib/libc/include/any-macos.13-any/dispatch/base.h
@@ -127,6 +127,33 @@
 #define DISPATCH_UNAVAILABLE_MSG(msg)
 #endif
 
+#if defined(__cplusplus)
+# if __cplusplus >= 201703L
+#  define DISPATCH_FALLTHROUGH [[fallthrough]]
+# elif __cplusplus >= 201103L
+#  if defined(__clang__)
+#   define DISPATCH_FALLTHROUGH [[clang::fallthrough]]
+#  elif defined(__GNUC__) && __GNUC__ >= 7
+#   define DISPATCH_FALLTHROUGH [[gnu::fallthrough]]
+#  else
+#   define DISPATCH_FALLTHROUGH
+#  endif
+# else
+#  define DISPATCH_FALLTHROUGH
+# endif
+#elif defined(__GNUC__) && __GNUC__ >= 7
+# define DISPATCH_FALLTHROUGH __attribute__((__fallthrough__))
+#elif defined(__clang__)
+# if __has_attribute(fallthrough) && __clang_major__ >= 5
+#  define DISPATCH_FALLTHROUGH __attribute__((__fallthrough__))
+# else
+#  define DISPATCH_FALLTHROUGH
+# endif
+#else
+# define DISPATCH_FALLTHROUGH
+#endif
+
+
 #define DISPATCH_LINUX_UNAVAILABLE()
 
 #ifdef __FreeBSD__
@@ -203,6 +230,20 @@
 #define DISPATCH_ASSUME_NONNULL_END
 #endif
 
+#if __has_feature(bounds_attributes)
+#define DISPATCH_ASSUME_ABI_SINGLE_BEGIN	_Pragma("clang abi_ptr_attr set(single)")
+#define DISPATCH_ASSUME_ABI_SINGLE_END		_Pragma("clang abi_ptr_attr set(unsafe_indexable)")
+#define DISPATCH_UNSAFE_INDEXABLE __attribute__((__unsafe_indexable__))
+#define DISPATCH_COUNTED_BY(X) __attribute__((__counted_by__(X)))
+#define DISPATCH_SIZED_BY(X) __attribute__((__sized_by__(X)))
+#else
+#define DISPATCH_ASSUME_ABI_SINGLE_BEGIN
+#define DISPATCH_ASSUME_ABI_SINGLE_END
+#define DISPATCH_UNSAFE_INDEXABLE
+#define DISPATCH_COUNTED_BY(X)
+#define DISPATCH_SIZED_BY(X)
+#endif
+
 #if !__has_feature(nullability)
 #ifndef _Nullable
 #define _Nullable
@@ -301,6 +342,10 @@
 #define DISPATCH_TRANSPARENT_UNION
 #endif
 
+DISPATCH_ASSUME_ABI_SINGLE_BEGIN
+
 typedef void (*dispatch_function_t)(void *_Nullable);
 
+DISPATCH_ASSUME_ABI_SINGLE_END
+
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/dispatch/block.h b/lib/libc/include/any-macos.13-any/dispatch/block.h
similarity index 99%
rename from lib/libc/include/x86_64-macos.10-none/dispatch/block.h
rename to lib/libc/include/any-macos.13-any/dispatch/block.h
index 5a28f48ce4..294ae8939a 100644
--- a/lib/libc/include/x86_64-macos.10-none/dispatch/block.h
+++ b/lib/libc/include/any-macos.13-any/dispatch/block.h
@@ -33,6 +33,7 @@
  */
 
 DISPATCH_ASSUME_NONNULL_BEGIN
+DISPATCH_ASSUME_ABI_SINGLE_BEGIN
 
 __BEGIN_DECLS
 
@@ -323,7 +324,7 @@ dispatch_block_perform(dispatch_block_flags_t flags,
  */
 API_AVAILABLE(macos(10.10), ios(8.0))
 DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
-long
+intptr_t
 dispatch_block_wait(dispatch_block_t block, dispatch_time_t timeout);
 
 /*!
@@ -416,11 +417,12 @@ dispatch_block_cancel(dispatch_block_t block);
 API_AVAILABLE(macos(10.10), ios(8.0))
 DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_WARN_RESULT DISPATCH_PURE
 DISPATCH_NOTHROW
-long
+intptr_t
 dispatch_block_testcancel(dispatch_block_t block);
 
 __END_DECLS
 
+DISPATCH_ASSUME_ABI_SINGLE_END
 DISPATCH_ASSUME_NONNULL_END
 
 #endif // __BLOCKS__
diff --git a/lib/libc/include/any-macos.13-any/dispatch/data.h b/lib/libc/include/any-macos.13-any/dispatch/data.h
new file mode 100644
index 0000000000..9e8e9a40ae
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/dispatch/data.h
@@ -0,0 +1,280 @@
+/*
+ * Copyright (c) 2009-2013 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __DISPATCH_DATA__
+#define __DISPATCH_DATA__
+
+#ifndef __DISPATCH_INDIRECT__
+#error "Please #include <dispatch/dispatch.h> instead of this file directly."
+#include <dispatch/base.h> // for HeaderDoc
+#endif
+
+DISPATCH_ASSUME_NONNULL_BEGIN
+DISPATCH_ASSUME_ABI_SINGLE_BEGIN
+
+__BEGIN_DECLS
+
+/*! @header
+ * Dispatch data objects describe contiguous or sparse regions of memory that
+ * may be managed by the system or by the application.
+ * Dispatch data objects are immutable, any direct access to memory regions
+ * represented by dispatch objects must not modify that memory.
+ */
+
+/*!
+ * @typedef dispatch_data_t
+ * A dispatch object representing memory regions.
+ */
+DISPATCH_DATA_DECL(dispatch_data);
+
+/*!
+ * @var dispatch_data_empty
+ * @discussion The singleton dispatch data object representing a zero-length
+ * memory region.
+ */
+#define dispatch_data_empty \
+		DISPATCH_GLOBAL_OBJECT(dispatch_data_t, _dispatch_data_empty)
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT struct dispatch_data_s _dispatch_data_empty;
+
+/*!
+ * @const DISPATCH_DATA_DESTRUCTOR_DEFAULT
+ * @discussion The default destructor for dispatch data objects.
+ * Used at data object creation to indicate that the supplied buffer should
+ * be copied into internal storage managed by the system.
+ */
+#define DISPATCH_DATA_DESTRUCTOR_DEFAULT NULL
+
+#ifdef __BLOCKS__
+/*! @parseOnly */
+#define DISPATCH_DATA_DESTRUCTOR_TYPE_DECL(name) \
+	DISPATCH_EXPORT const dispatch_block_t _dispatch_data_destructor_##name
+#else
+#define DISPATCH_DATA_DESTRUCTOR_TYPE_DECL(name) \
+	DISPATCH_EXPORT const dispatch_function_t \
+	_dispatch_data_destructor_##name
+#endif /* __BLOCKS__ */
+
+/*!
+ * @const DISPATCH_DATA_DESTRUCTOR_FREE
+ * @discussion The destructor for dispatch data objects created from a malloc'd
+ * buffer. Used at data object creation to indicate that the supplied buffer
+ * was allocated by the malloc() family and should be destroyed with free(3).
+ */
+#define DISPATCH_DATA_DESTRUCTOR_FREE (_dispatch_data_destructor_free)
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_DATA_DESTRUCTOR_TYPE_DECL(free);
+
+/*!
+ * @const DISPATCH_DATA_DESTRUCTOR_MUNMAP
+ * @discussion The destructor for dispatch data objects that have been created
+ * from buffers that require deallocation with munmap(2).
+ */
+#define DISPATCH_DATA_DESTRUCTOR_MUNMAP (_dispatch_data_destructor_munmap)
+API_AVAILABLE(macos(10.9), ios(7.0))
+DISPATCH_DATA_DESTRUCTOR_TYPE_DECL(munmap);
+
+#ifdef __BLOCKS__
+/*!
+ * @function dispatch_data_create
+ * Creates a dispatch data object from the given contiguous buffer of memory. If
+ * a non-default destructor is provided, ownership of the buffer remains with
+ * the caller (i.e. the bytes will not be copied). The last release of the data
+ * object will result in the invocation of the specified destructor on the
+ * specified queue to free the buffer.
+ *
+ * If the DISPATCH_DATA_DESTRUCTOR_FREE destructor is provided the buffer will
+ * be freed via free(3) and the queue argument ignored.
+ *
+ * If the DISPATCH_DATA_DESTRUCTOR_DEFAULT destructor is provided, data object
+ * creation will copy the buffer into internal memory managed by the system.
+ *
+ * @param buffer	A contiguous buffer of data.
+ * @param size		The size of the contiguous buffer of data.
+ * @param queue		The queue to which the destructor should be submitted.
+ * @param destructor	The destructor responsible for freeing the data when it
+ *			is no longer needed.
+ * @result		A newly created dispatch data object.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_data_t
+dispatch_data_create(const void *DISPATCH_SIZED_BY(size) buffer,
+	size_t size,
+	dispatch_queue_t _Nullable queue,
+	dispatch_block_t _Nullable destructor);
+#endif /* __BLOCKS__ */
+
+/*!
+ * @function dispatch_data_get_size
+ * Returns the logical size of the memory region(s) represented by the specified
+ * dispatch data object.
+ *
+ * @param data	The dispatch data object to query.
+ * @result	The number of bytes represented by the data object.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_PURE DISPATCH_NONNULL1 DISPATCH_NOTHROW
+size_t
+dispatch_data_get_size(dispatch_data_t data);
+
+/*!
+ * @function dispatch_data_create_map
+ * Maps the memory represented by the specified dispatch data object as a single
+ * contiguous memory region and returns a new data object representing it.
+ * If non-NULL references to a pointer and a size variable are provided, they
+ * are filled with the location and extent of that region. These allow direct
+ * read access to the represented memory, but are only valid until the returned
+ * object is released. Under ARC, if that object is held in a variable with
+ * automatic storage, care needs to be taken to ensure that it is not released
+ * by the compiler before memory access via the pointer has been completed.
+ *
+ * @param data		The dispatch data object to map.
+ * @param buffer_ptr	A pointer to a pointer variable to be filled with the
+ *			location of the mapped contiguous memory region, or
+ *			NULL.
+ * @param size_ptr	A pointer to a size_t variable to be filled with the
+ *			size of the mapped contiguous memory region, or NULL.
+ * @result		A newly created dispatch data object.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_RETURNS_RETAINED
+DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_data_t
+dispatch_data_create_map(dispatch_data_t data,
+	const void *_Nullable DISPATCH_SIZED_BY(*size_ptr) *_Nullable buffer_ptr,
+	size_t *_Nullable size_ptr);
+
+/*!
+ * @function dispatch_data_create_concat
+ * Returns a new dispatch data object representing the concatenation of the
+ * specified data objects. Those objects may be released by the application
+ * after the call returns (however, the system might not deallocate the memory
+ * region(s) described by them until the newly created object has also been
+ * released).
+ *
+ * @param data1	The data object representing the region(s) of memory to place
+ *		at the beginning of the newly created object.
+ * @param data2	The data object representing the region(s) of memory to place
+ *		at the end of the newly created object.
+ * @result	A newly created object representing the concatenation of the
+ *		data1 and data2 objects.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_RETURNS_RETAINED
+DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_data_t
+dispatch_data_create_concat(dispatch_data_t data1, dispatch_data_t data2);
+
+/*!
+ * @function dispatch_data_create_subrange
+ * Returns a new dispatch data object representing a subrange of the specified
+ * data object, which may be released by the application after the call returns
+ * (however, the system might not deallocate the memory region(s) described by
+ * that object until the newly created object has also been released).
+ *
+ * @param data		The data object representing the region(s) of memory to
+ *			create a subrange of.
+ * @param offset	The offset into the data object where the subrange
+ *			starts.
+ * @param length	The length of the range.
+ * @result		A newly created object representing the specified
+ *			subrange of the data object.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_RETURNS_RETAINED
+DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_data_t
+dispatch_data_create_subrange(dispatch_data_t data,
+	size_t offset,
+	size_t length);
+
+#ifdef __BLOCKS__
+/*!
+ * @typedef dispatch_data_applier_t
+ * A block to be invoked for every contiguous memory region in a data object.
+ *
+ * @param region	A data object representing the current region.
+ * @param offset	The logical offset of the current region to the start
+ *			of the data object.
+ * @param buffer	The location of the memory for the current region.
+ * @param size		The size of the memory for the current region.
+ * @result		A Boolean indicating whether traversal should continue.
+ */
+typedef bool (^dispatch_data_applier_t)(dispatch_data_t region,
+	size_t offset,
+	const void *DISPATCH_SIZED_BY(size) buffer,
+	size_t size);
+
+/*!
+ * @function dispatch_data_apply
+ * Traverse the memory regions represented by the specified dispatch data object
+ * in logical order and invoke the specified block once for every contiguous
+ * memory region encountered.
+ *
+ * Each invocation of the block is passed a data object representing the current
+ * region and its logical offset, along with the memory location and extent of
+ * the region. These allow direct read access to the memory region, but are only
+ * valid until the passed-in region object is released. Note that the region
+ * object is released by the system when the block returns, it is the
+ * responsibility of the application to retain it if the region object or the
+ * associated memory location are needed after the block returns.
+ *
+ * @param data		The data object to traverse.
+ * @param applier	The block to be invoked for every contiguous memory
+ *			region in the data object.
+ * @result		A Boolean indicating whether traversal completed
+ *			successfully.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
+bool
+dispatch_data_apply(dispatch_data_t data,
+	DISPATCH_NOESCAPE dispatch_data_applier_t applier);
+#endif /* __BLOCKS__ */
+
+/*!
+ * @function dispatch_data_copy_region
+ * Finds the contiguous memory region containing the specified location among
+ * the regions represented by the specified object and returns a copy of the
+ * internal dispatch data object representing that region along with its logical
+ * offset in the specified object.
+ *
+ * @param data		The dispatch data object to query.
+ * @param location	The logical position in the data object to query.
+ * @param offset_ptr	A pointer to a size_t variable to be filled with the
+ *			logical offset of the returned region object to the
+ *			start of the queried data object.
+ * @result		A newly created dispatch data object.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_RETURNS_RETAINED
+DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_data_t
+dispatch_data_copy_region(dispatch_data_t data,
+	size_t location,
+	size_t *offset_ptr);
+
+__END_DECLS
+
+DISPATCH_ASSUME_ABI_SINGLE_END
+DISPATCH_ASSUME_NONNULL_END
+
+#endif /* __DISPATCH_DATA__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/dispatch/group.h b/lib/libc/include/any-macos.13-any/dispatch/group.h
similarity index 99%
rename from lib/libc/include/x86_64-macos.10-none/dispatch/group.h
rename to lib/libc/include/any-macos.13-any/dispatch/group.h
index bb9bad30e3..9e36f30fc9 100644
--- a/lib/libc/include/x86_64-macos.10-none/dispatch/group.h
+++ b/lib/libc/include/any-macos.13-any/dispatch/group.h
@@ -27,6 +27,7 @@
 #endif
 
 DISPATCH_ASSUME_NONNULL_BEGIN
+DISPATCH_ASSUME_ABI_SINGLE_BEGIN
 
 /*!
  * @typedef dispatch_group_t
@@ -160,7 +161,7 @@ dispatch_group_async_f(dispatch_group_t group,
  */
 API_AVAILABLE(macos(10.6), ios(4.0))
 DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-long
+intptr_t
 dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout);
 
 /*!
@@ -274,6 +275,7 @@ dispatch_group_leave(dispatch_group_t group);
 
 __END_DECLS
 
+DISPATCH_ASSUME_ABI_SINGLE_END
 DISPATCH_ASSUME_NONNULL_END
 
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/dispatch/io.h b/lib/libc/include/any-macos.13-any/dispatch/io.h
new file mode 100644
index 0000000000..30e2692a83
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/dispatch/io.h
@@ -0,0 +1,599 @@
+/*
+ * Copyright (c) 2009-2013 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __DISPATCH_IO__
+#define __DISPATCH_IO__
+
+#ifndef __DISPATCH_INDIRECT__
+#error "Please #include <dispatch/dispatch.h> instead of this file directly."
+#include <dispatch/base.h> // for HeaderDoc
+#endif
+
+DISPATCH_ASSUME_NONNULL_BEGIN
+DISPATCH_ASSUME_ABI_SINGLE_BEGIN
+
+__BEGIN_DECLS
+
+/*! @header
+ * Dispatch I/O provides both stream and random access asynchronous read and
+ * write operations on file descriptors. One or more dispatch I/O channels may
+ * be created from a file descriptor as either the DISPATCH_IO_STREAM type or
+ * DISPATCH_IO_RANDOM type. Once a channel has been created the application may
+ * schedule asynchronous read and write operations.
+ *
+ * The application may set policies on the dispatch I/O channel to indicate the
+ * desired frequency of I/O handlers for long-running operations.
+ *
+ * Dispatch I/O also provides a memory management model for I/O buffers that
+ * avoids unnecessary copying of data when pipelined between channels. Dispatch
+ * I/O monitors the overall memory pressure and I/O access patterns for the
+ * application to optimize resource utilization.
+ */
+
+/*!
+ * @typedef dispatch_fd_t
+ * Native file descriptor type for the platform.
+ */
+#if defined(_WIN32)
+typedef intptr_t dispatch_fd_t;
+#else
+typedef int dispatch_fd_t;
+#endif
+
+/*!
+ * @functiongroup Dispatch I/O Convenience API
+ * Convenience wrappers around the dispatch I/O channel API, with simpler
+ * callback handler semantics and no explicit management of channel objects.
+ * File descriptors passed to the convenience API are treated as streams, and
+ * scheduling multiple operations on one file descriptor via the convenience API
+ * may incur more overhead than by using the dispatch I/O channel API directly.
+ */
+
+#ifdef __BLOCKS__
+/*!
+ * @function dispatch_read
+ * Schedule a read operation for asynchronous execution on the specified file
+ * descriptor. The specified handler is enqueued with the data read from the
+ * file descriptor when the operation has completed or an error occurs.
+ *
+ * The data object passed to the handler will be automatically released by the
+ * system when the handler returns. It is the responsibility of the application
+ * to retain, concatenate or copy the data object if it is needed after the
+ * handler returns.
+ *
+ * The data object passed to the handler will only contain as much data as is
+ * currently available from the file descriptor (up to the specified length).
+ *
+ * If an unrecoverable error occurs on the file descriptor, the handler will be
+ * enqueued with the appropriate error code along with a data object of any data
+ * that could be read successfully.
+ *
+ * An invocation of the handler with an error code of zero and an empty data
+ * object indicates that EOF was reached.
+ *
+ * The system takes control of the file descriptor until the handler is
+ * enqueued, and during this time file descriptor flags such as O_NONBLOCK will
+ * be modified by the system on behalf of the application. It is an error for
+ * the application to modify a file descriptor directly while it is under the
+ * control of the system, but it may create additional dispatch I/O convenience
+ * operations or dispatch I/O channels associated with that file descriptor.
+ *
+ * @param fd		The file descriptor from which to read the data.
+ * @param length	The length of data to read from the file descriptor,
+ *			or SIZE_MAX to indicate that all of the data currently
+ *			available from the file descriptor should be read.
+ * @param queue		The dispatch queue to which the handler should be
+ *			submitted.
+ * @param handler	The handler to enqueue when data is ready to be
+ *			delivered.
+ *		param data	The data read from the file descriptor.
+ *		param error	An errno condition for the read operation or
+ *				zero if the read was successful.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL3 DISPATCH_NONNULL4 DISPATCH_NOTHROW
+void
+dispatch_read(dispatch_fd_t fd,
+	size_t length,
+	dispatch_queue_t queue,
+	void (^handler)(dispatch_data_t data, int error));
+
+/*!
+ * @function dispatch_write
+ * Schedule a write operation for asynchronous execution on the specified file
+ * descriptor. The specified handler is enqueued when the operation has
+ * completed or an error occurs.
+ *
+ * If an unrecoverable error occurs on the file descriptor, the handler will be
+ * enqueued with the appropriate error code along with the data that could not
+ * be successfully written.
+ *
+ * An invocation of the handler with an error code of zero indicates that the
+ * data was fully written to the channel.
+ *
+ * The system takes control of the file descriptor until the handler is
+ * enqueued, and during this time file descriptor flags such as O_NONBLOCK will
+ * be modified by the system on behalf of the application. It is an error for
+ * the application to modify a file descriptor directly while it is under the
+ * control of the system, but it may create additional dispatch I/O convenience
+ * operations or dispatch I/O channels associated with that file descriptor.
+ *
+ * @param fd		The file descriptor to which to write the data.
+ * @param data		The data object to write to the file descriptor.
+ * @param queue		The dispatch queue to which the handler should be
+ *			submitted.
+ * @param handler	The handler to enqueue when the data has been written.
+ *		param data	The data that could not be written to the I/O
+ *				channel, or NULL.
+ *		param error	An errno condition for the write operation or
+ *				zero if the write was successful.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_NONNULL3 DISPATCH_NONNULL4
+DISPATCH_NOTHROW
+void
+dispatch_write(dispatch_fd_t fd,
+	dispatch_data_t data,
+	dispatch_queue_t queue,
+	void (^handler)(dispatch_data_t _Nullable data, int error));
+#endif /* __BLOCKS__ */
+
+/*!
+ * @functiongroup Dispatch I/O Channel API
+ */
+
+/*!
+ * @typedef dispatch_io_t
+ * A dispatch I/O channel represents the asynchronous I/O policy applied to a
+ * file descriptor. I/O channels are first class dispatch objects and may be
+ * retained and released, suspended and resumed, etc.
+ */
+DISPATCH_DECL(dispatch_io);
+
+/*!
+ * @typedef dispatch_io_type_t
+ * The type of a dispatch I/O channel:
+ *
+ * @const DISPATCH_IO_STREAM	A dispatch I/O channel representing a stream of
+ * bytes. Read and write operations on a channel of this type are performed
+ * serially (in order of creation) and read/write data at the file pointer
+ * position that is current at the time the operation starts executing.
+ * Operations of different type (read vs. write) may be performed simultaneously.
+ * Offsets passed to operations on a channel of this type are ignored.
+ *
+ * @const DISPATCH_IO_RANDOM	A dispatch I/O channel representing a random
+ * access file. Read and write operations on a channel of this type may be
+ * performed concurrently and read/write data at the specified offset. Offsets
+ * are interpreted relative to the file pointer position current at the time the
+ * I/O channel is created. Attempting to create a channel of this type for a
+ * file descriptor that is not seekable will result in an error.
+ */
+#define DISPATCH_IO_STREAM 0
+#define DISPATCH_IO_RANDOM 1
+
+typedef unsigned long dispatch_io_type_t;
+
+#ifdef __BLOCKS__
+/*!
+ * @function dispatch_io_create
+ * Create a dispatch I/O channel associated with a file descriptor. The system
+ * takes control of the file descriptor until the channel is closed, an error
+ * occurs on the file descriptor or all references to the channel are released.
+ * At that time the specified cleanup handler will be enqueued and control over
+ * the file descriptor relinquished.
+ *
+ * While a file descriptor is under the control of a dispatch I/O channel, file
+ * descriptor flags such as O_NONBLOCK will be modified by the system on behalf
+ * of the application. It is an error for the application to modify a file
+ * descriptor directly while it is under the control of a dispatch I/O channel,
+ * but it may create additional channels associated with that file descriptor.
+ *
+ * @param type	The desired type of I/O channel (DISPATCH_IO_STREAM
+ *		or DISPATCH_IO_RANDOM).
+ * @param fd	The file descriptor to associate with the I/O channel.
+ * @param queue	The dispatch queue to which the handler should be submitted.
+ * @param cleanup_handler	The handler to enqueue when the system
+ *				relinquishes control over the file descriptor.
+ *	param error		An errno condition if control is relinquished
+ *				because channel creation failed, zero otherwise.
+ * @result	The newly created dispatch I/O channel or NULL if an error
+ *		occurred (invalid type specified).
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
+DISPATCH_NOTHROW
+dispatch_io_t
+dispatch_io_create(dispatch_io_type_t type,
+	dispatch_fd_t fd,
+	dispatch_queue_t queue,
+	void (^cleanup_handler)(int error));
+
+/*!
+ * @function dispatch_io_create_with_path
+ * Create a dispatch I/O channel associated with a path name. The specified
+ * path, oflag and mode parameters will be passed to open(2) when the first I/O
+ * operation on the channel is ready to execute and the resulting file
+ * descriptor will remain open and under the control of the system until the
+ * channel is closed, an error occurs on the file descriptor or all references
+ * to the channel are released. At that time the file descriptor will be closed
+ * and the specified cleanup handler will be enqueued.
+ *
+ * @param type	The desired type of I/O channel (DISPATCH_IO_STREAM
+ *		or DISPATCH_IO_RANDOM).
+ * @param path	The absolute path to associate with the I/O channel.
+ * @param oflag	The flags to pass to open(2) when opening the file at
+ *		path.
+ * @param mode	The mode to pass to open(2) when creating the file at
+ *		path (i.e. with flag O_CREAT), zero otherwise.
+ * @param queue	The dispatch queue to which the handler should be
+ *		submitted.
+ * @param cleanup_handler	The handler to enqueue when the system
+ *				has closed the file at path.
+ *	param error		An errno condition if control is relinquished
+ *				because channel creation or opening of the
+ *				specified file failed, zero otherwise.
+ * @result	The newly created dispatch I/O channel or NULL if an error
+ *		occurred (invalid type or non-absolute path specified).
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED
+DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_io_t
+dispatch_io_create_with_path(dispatch_io_type_t type,
+	const char *DISPATCH_UNSAFE_INDEXABLE path, int oflag,
+	mode_t mode, dispatch_queue_t queue,
+	void (^cleanup_handler)(int error));
+
+/*!
+ * @function dispatch_io_create_with_io
+ * Create a new dispatch I/O channel from an existing dispatch I/O channel.
+ * The new channel inherits the file descriptor or path name associated with
+ * the existing channel, but not its channel type or policies.
+ *
+ * If the existing channel is associated with a file descriptor, control by the
+ * system over that file descriptor is extended until the new channel is also
+ * closed, an error occurs on the file descriptor, or all references to both
+ * channels are released. At that time the specified cleanup handler will be
+ * enqueued and control over the file descriptor relinquished.
+ *
+ * While a file descriptor is under the control of a dispatch I/O channel, file
+ * descriptor flags such as O_NONBLOCK will be modified by the system on behalf
+ * of the application. It is an error for the application to modify a file
+ * descriptor directly while it is under the control of a dispatch I/O channel,
+ * but it may create additional channels associated with that file descriptor.
+ *
+ * @param type	The desired type of I/O channel (DISPATCH_IO_STREAM
+ *		or DISPATCH_IO_RANDOM).
+ * @param io	The existing channel to create the new I/O channel from.
+ * @param queue	The dispatch queue to which the handler should be submitted.
+ * @param cleanup_handler	The handler to enqueue when the system
+ *				relinquishes control over the file descriptor
+ *				(resp. closes the file at path) associated with
+ *				the existing channel.
+ *	param error		An errno condition if control is relinquished
+ *				because channel creation failed, zero otherwise.
+ * @result	The newly created dispatch I/O channel or NULL if an error
+ *		occurred (invalid type specified).
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED
+DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_io_t
+dispatch_io_create_with_io(dispatch_io_type_t type,
+	dispatch_io_t io,
+	dispatch_queue_t queue,
+	void (^cleanup_handler)(int error));
+
+/*!
+ * @typedef dispatch_io_handler_t
+ * The prototype of I/O handler blocks for dispatch I/O operations.
+ *
+ * @param done		A flag indicating whether the operation is complete.
+ * @param data		The data object to be handled.
+ * @param error		An errno condition for the operation.
+ */
+typedef void (^dispatch_io_handler_t)(bool done, dispatch_data_t _Nullable data,
+		int error);
+
+/*!
+ * @function dispatch_io_read
+ * Schedule a read operation for asynchronous execution on the specified I/O
+ * channel. The I/O handler is enqueued one or more times depending on the
+ * general load of the system and the policy specified on the I/O channel.
+ *
+ * Any data read from the channel is described by the dispatch data object
+ * passed to the I/O handler. This object will be automatically released by the
+ * system when the I/O handler returns. It is the responsibility of the
+ * application to retain, concatenate or copy the data object if it is needed
+ * after the I/O handler returns.
+ *
+ * Dispatch I/O handlers are not reentrant. The system will ensure that no new
+ * I/O handler instance is invoked until the previously enqueued handler block
+ * has returned.
+ *
+ * An invocation of the I/O handler with the done flag set indicates that the
+ * read operation is complete and that the handler will not be enqueued again.
+ *
+ * If an unrecoverable error occurs on the I/O channel's underlying file
+ * descriptor, the I/O handler will be enqueued with the done flag set, the
+ * appropriate error code and a NULL data object.
+ *
+ * An invocation of the I/O handler with the done flag set, an error code of
+ * zero and an empty data object indicates that EOF was reached.
+ *
+ * @param channel	The dispatch I/O channel from which to read the data.
+ * @param offset	The offset relative to the channel position from which
+ *			to start reading (only for DISPATCH_IO_RANDOM).
+ * @param length	The length of data to read from the I/O channel, or
+ *			SIZE_MAX to indicate that data should be read until EOF
+ *			is reached.
+ * @param queue		The dispatch queue to which the I/O handler should be
+ *			submitted.
+ * @param io_handler	The I/O handler to enqueue when data is ready to be
+ *			delivered.
+ *	param done	A flag indicating whether the operation is complete.
+ *	param data	An object with the data most recently read from the
+ *			I/O channel as part of this read operation, or NULL.
+ *	param error	An errno condition for the read operation or zero if
+ *			the read was successful.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL4 DISPATCH_NONNULL5
+DISPATCH_NOTHROW
+void
+dispatch_io_read(dispatch_io_t channel,
+	off_t offset,
+	size_t length,
+	dispatch_queue_t queue,
+	dispatch_io_handler_t io_handler);
+
+/*!
+ * @function dispatch_io_write
+ * Schedule a write operation for asynchronous execution on the specified I/O
+ * channel. The I/O handler is enqueued one or more times depending on the
+ * general load of the system and the policy specified on the I/O channel.
+ *
+ * Any data remaining to be written to the I/O channel is described by the
+ * dispatch data object passed to the I/O handler. This object will be
+ * automatically released by the system when the I/O handler returns. It is the
+ * responsibility of the application to retain, concatenate or copy the data
+ * object if it is needed after the I/O handler returns.
+ *
+ * Dispatch I/O handlers are not reentrant. The system will ensure that no new
+ * I/O handler instance is invoked until the previously enqueued handler block
+ * has returned.
+ *
+ * An invocation of the I/O handler with the done flag set indicates that the
+ * write operation is complete and that the handler will not be enqueued again.
+ *
+ * If an unrecoverable error occurs on the I/O channel's underlying file
+ * descriptor, the I/O handler will be enqueued with the done flag set, the
+ * appropriate error code and an object containing the data that could not be
+ * written.
+ *
+ * An invocation of the I/O handler with the done flag set and an error code of
+ * zero indicates that the data was fully written to the channel.
+ *
+ * @param channel	The dispatch I/O channel on which to write the data.
+ * @param offset	The offset relative to the channel position from which
+ *			to start writing (only for DISPATCH_IO_RANDOM).
+ * @param data		The data to write to the I/O channel. The data object
+ *			will be retained by the system until the write operation
+ *			is complete.
+ * @param queue		The dispatch queue to which the I/O handler should be
+ *			submitted.
+ * @param io_handler	The I/O handler to enqueue when data has been delivered.
+ *	param done	A flag indicating whether the operation is complete.
+ *	param data	An object of the data remaining to be
+ *			written to the I/O channel as part of this write
+ *			operation, or NULL.
+ *	param error	An errno condition for the write operation or zero
+ *			if the write was successful.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NONNULL4
+DISPATCH_NONNULL5 DISPATCH_NOTHROW
+void
+dispatch_io_write(dispatch_io_t channel,
+	off_t offset,
+	dispatch_data_t data,
+	dispatch_queue_t queue,
+	dispatch_io_handler_t io_handler);
+#endif /* __BLOCKS__ */
+
+/*!
+ * @typedef dispatch_io_close_flags_t
+ * The type of flags you can set on a dispatch_io_close() call
+ *
+ * @const DISPATCH_IO_STOP	Stop outstanding operations on a channel when
+ *				the channel is closed.
+ */
+#define DISPATCH_IO_STOP 0x1
+
+typedef unsigned long dispatch_io_close_flags_t;
+
+/*!
+ * @function dispatch_io_close
+ * Close the specified I/O channel to new read or write operations; scheduling
+ * operations on a closed channel results in their handler returning an error.
+ *
+ * If the DISPATCH_IO_STOP flag is provided, the system will make a best effort
+ * to interrupt any outstanding read and write operations on the I/O channel,
+ * otherwise those operations will run to completion normally.
+ * Partial results of read and write operations may be returned even after a
+ * channel is closed with the DISPATCH_IO_STOP flag.
+ * The final invocation of an I/O handler of an interrupted operation will be
+ * passed an ECANCELED error code, as will the I/O handler of an operation
+ * scheduled on a closed channel.
+ *
+ * @param channel	The dispatch I/O channel to close.
+ * @param flags		The flags for the close operation.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
+void
+dispatch_io_close(dispatch_io_t channel, dispatch_io_close_flags_t flags);
+
+#ifdef __BLOCKS__
+/*!
+ * @function dispatch_io_barrier
+ * Schedule a barrier operation on the specified I/O channel; all previously
+ * scheduled operations on the channel will complete before the provided
+ * barrier block is enqueued onto the global queue determined by the channel's
+ * target queue, and no subsequently scheduled operations will start until the
+ * barrier block has returned.
+ *
+ * If multiple channels are associated with the same file descriptor, a barrier
+ * operation scheduled on any of these channels will act as a barrier across all
+ * channels in question, i.e. all previously scheduled operations on any of the
+ * channels will complete before the barrier block is enqueued, and no
+ * operations subsequently scheduled on any of the channels will start until the
+ * barrier block has returned.
+ *
+ * While the barrier block is running, it may safely operate on the channel's
+ * underlying file descriptor with fsync(2), lseek(2) etc. (but not close(2)).
+ *
+ * @param channel	The dispatch I/O channel to schedule the barrier on.
+ * @param barrier	The barrier block.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
+void
+dispatch_io_barrier(dispatch_io_t channel, dispatch_block_t barrier);
+#endif /* __BLOCKS__ */
+
+/*!
+ * @function dispatch_io_get_descriptor
+ * Returns the file descriptor underlying a dispatch I/O channel.
+ *
+ * Will return -1 for a channel closed with dispatch_io_close() and for a
+ * channel associated with a path name that has not yet been open(2)ed.
+ *
+ * If called from a barrier block scheduled on a channel associated with a path
+ * name that has not yet been open(2)ed, this will trigger the channel open(2)
+ * operation and return the resulting file descriptor.
+ *
+ * @param channel	The dispatch I/O channel to query.
+ * @result		The file descriptor underlying the channel, or -1.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_fd_t
+dispatch_io_get_descriptor(dispatch_io_t channel);
+
+/*!
+ * @function dispatch_io_set_high_water
+ * Set a high water mark on the I/O channel for all operations.
+ *
+ * The system will make a best effort to enqueue I/O handlers with partial
+ * results as soon the number of bytes processed by an operation (i.e. read or
+ * written) reaches the high water mark.
+ *
+ * The size of data objects passed to I/O handlers for this channel will never
+ * exceed the specified high water mark.
+ *
+ * The default value for the high water mark is unlimited (i.e. SIZE_MAX).
+ *
+ * @param channel	The dispatch I/O channel on which to set the policy.
+ * @param high_water	The number of bytes to use as a high water mark.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
+void
+dispatch_io_set_high_water(dispatch_io_t channel, size_t high_water);
+
+/*!
+ * @function dispatch_io_set_low_water
+ * Set a low water mark on the I/O channel for all operations.
+ *
+ * The system will process (i.e. read or write) at least the low water mark
+ * number of bytes for an operation before enqueueing I/O handlers with partial
+ * results.
+ *
+ * The size of data objects passed to intermediate I/O handler invocations for
+ * this channel (i.e. excluding the final invocation) will never be smaller than
+ * the specified low water mark, except if the channel has an interval with the
+ * DISPATCH_IO_STRICT_INTERVAL flag set or if EOF or an error was encountered.
+ *
+ * I/O handlers should be prepared to receive amounts of data significantly
+ * larger than the low water mark in general. If an I/O handler requires
+ * intermediate results of fixed size, set both the low and and the high water
+ * mark to that size.
+ *
+ * The default value for the low water mark is unspecified, but must be assumed
+ * to be such that intermediate handler invocations may occur.
+ * If I/O handler invocations with partial results are not desired, set the
+ * low water mark to SIZE_MAX.
+ *
+ * @param channel	The dispatch I/O channel on which to set the policy.
+ * @param low_water	The number of bytes to use as a low water mark.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
+void
+dispatch_io_set_low_water(dispatch_io_t channel, size_t low_water);
+
+/*!
+ * @typedef dispatch_io_interval_flags_t
+ * Type of flags to set on dispatch_io_set_interval()
+ *
+ * @const DISPATCH_IO_STRICT_INTERVAL	Enqueue I/O handlers at a channel's
+ * interval setting even if the amount of data ready to be delivered is inferior
+ * to the low water mark (or zero).
+ */
+#define DISPATCH_IO_STRICT_INTERVAL 0x1
+
+typedef unsigned long dispatch_io_interval_flags_t;
+
+/*!
+ * @function dispatch_io_set_interval
+ * Set a nanosecond interval at which I/O handlers are to be enqueued on the
+ * I/O channel for all operations.
+ *
+ * This allows an application to receive periodic feedback on the progress of
+ * read and write operations, e.g. for the purposes of displaying progress bars.
+ *
+ * If the amount of data ready to be delivered to an I/O handler at the interval
+ * is inferior to the channel low water mark, the handler will only be enqueued
+ * if the DISPATCH_IO_STRICT_INTERVAL flag is set.
+ *
+ * Note that the system may defer enqueueing interval I/O handlers by a small
+ * unspecified amount of leeway in order to align with other system activity for
+ * improved system performance or power consumption.
+ *
+ * @param channel	The dispatch I/O channel on which to set the policy.
+ * @param interval	The interval in nanoseconds at which delivery of the I/O
+ *					handler is desired.
+ * @param flags		Flags indicating desired data delivery behavior at
+ *					interval time.
+ */
+API_AVAILABLE(macos(10.7), ios(5.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
+void
+dispatch_io_set_interval(dispatch_io_t channel,
+	uint64_t interval,
+	dispatch_io_interval_flags_t flags);
+
+__END_DECLS
+
+DISPATCH_ASSUME_ABI_SINGLE_END
+DISPATCH_ASSUME_NONNULL_END
+
+#endif /* __DISPATCH_IO__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/dispatch/object.h b/lib/libc/include/any-macos.13-any/dispatch/object.h
similarity index 98%
rename from lib/libc/include/x86_64-macos.10-none/dispatch/object.h
rename to lib/libc/include/any-macos.13-any/dispatch/object.h
index 3d89eb1fe6..a38fc4be64 100644
--- a/lib/libc/include/x86_64-macos.10-none/dispatch/object.h
+++ b/lib/libc/include/any-macos.13-any/dispatch/object.h
@@ -31,6 +31,7 @@
 #endif
 
 DISPATCH_ASSUME_NONNULL_BEGIN
+DISPATCH_ASSUME_ABI_SINGLE_BEGIN
 
 /*!
  * @typedef dispatch_object_t
@@ -456,7 +457,7 @@ dispatch_set_qos_class_floor(dispatch_object_t object,
  */
 DISPATCH_UNAVAILABLE
 DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
-long
+intptr_t
 dispatch_wait(void *object, dispatch_time_t timeout);
 #if __has_extension(c_generic_selections)
 #define dispatch_wait(object, timeout) \
@@ -554,7 +555,7 @@ dispatch_cancel(void *object);
 DISPATCH_UNAVAILABLE
 DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_WARN_RESULT DISPATCH_PURE
 DISPATCH_NOTHROW
-long
+intptr_t
 dispatch_testcancel(void *object);
 #if __has_extension(c_generic_selections)
 #define dispatch_testcancel(object) \
@@ -591,16 +592,19 @@ API_DEPRECATED("unsupported interface", macos(10.6,10.9), ios(4.0,6.0))
 DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_NOTHROW DISPATCH_COLD
 __attribute__((__format__(printf,2,3)))
 void
-dispatch_debug(dispatch_object_t object, const char *message, ...);
+dispatch_debug(dispatch_object_t object,
+			   const char *DISPATCH_UNSAFE_INDEXABLE message, ...);
 
 API_DEPRECATED("unsupported interface", macos(10.6,10.9), ios(4.0,6.0))
 DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_NOTHROW DISPATCH_COLD
 __attribute__((__format__(printf,2,0)))
 void
-dispatch_debugv(dispatch_object_t object, const char *message, va_list ap);
+dispatch_debugv(dispatch_object_t object,
+				const char *DISPATCH_UNSAFE_INDEXABLE message, va_list ap);
 
 __END_DECLS
 
+DISPATCH_ASSUME_ABI_SINGLE_END
 DISPATCH_ASSUME_NONNULL_END
 
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/dispatch/once.h b/lib/libc/include/any-macos.13-any/dispatch/once.h
new file mode 100644
index 0000000000..2792f902d5
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/dispatch/once.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2008-2010 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __DISPATCH_ONCE__
+#define __DISPATCH_ONCE__
+
+#ifndef __DISPATCH_INDIRECT__
+#error "Please #include <dispatch/dispatch.h> instead of this file directly."
+#include <dispatch/base.h> // for HeaderDoc
+#endif
+
+DISPATCH_ASSUME_NONNULL_BEGIN
+DISPATCH_ASSUME_ABI_SINGLE_BEGIN
+
+__BEGIN_DECLS
+
+/*!
+ * @typedef dispatch_once_t
+ *
+ * @abstract
+ * A predicate for use with dispatch_once(). It must be initialized to zero.
+ * Note: static and global variables default to zero.
+ */
+DISPATCH_SWIFT3_UNAVAILABLE("Use lazily initialized globals instead")
+typedef intptr_t dispatch_once_t;
+
+#if defined(__x86_64__) || defined(__i386__) || defined(__s390x__)
+#define DISPATCH_ONCE_INLINE_FASTPATH 1
+#elif defined(__APPLE__)
+#define DISPATCH_ONCE_INLINE_FASTPATH 1
+#else
+#define DISPATCH_ONCE_INLINE_FASTPATH 0
+#endif
+
+/*!
+ * @function dispatch_once
+ *
+ * @abstract
+ * Execute a block once and only once.
+ *
+ * @param predicate
+ * A pointer to a dispatch_once_t that is used to test whether the block has
+ * completed or not.
+ *
+ * @param block
+ * The block to execute once.
+ *
+ * @discussion
+ * Always call dispatch_once() before using or testing any variables that are
+ * initialized by the block.
+ */
+#ifdef __BLOCKS__
+API_AVAILABLE(macos(10.6), ios(4.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
+DISPATCH_SWIFT3_UNAVAILABLE("Use lazily initialized globals instead")
+void
+dispatch_once(dispatch_once_t *predicate,
+		DISPATCH_NOESCAPE dispatch_block_t block);
+
+#if DISPATCH_ONCE_INLINE_FASTPATH
+DISPATCH_INLINE DISPATCH_ALWAYS_INLINE DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
+DISPATCH_SWIFT3_UNAVAILABLE("Use lazily initialized globals instead")
+void
+_dispatch_once(dispatch_once_t *predicate,
+		DISPATCH_NOESCAPE dispatch_block_t block)
+{
+	if (DISPATCH_EXPECT(*predicate, ~0l) != ~0l) {
+		dispatch_once(predicate, block);
+	} else {
+		dispatch_compiler_barrier();
+	}
+	DISPATCH_COMPILER_CAN_ASSUME(*predicate == ~0l);
+}
+#undef dispatch_once
+#define dispatch_once _dispatch_once
+#endif
+#endif // DISPATCH_ONCE_INLINE_FASTPATH
+
+API_AVAILABLE(macos(10.6), ios(4.0))
+DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NOTHROW
+DISPATCH_SWIFT3_UNAVAILABLE("Use lazily initialized globals instead")
+void
+dispatch_once_f(dispatch_once_t *predicate, void *_Nullable context,
+		dispatch_function_t function);
+
+#if DISPATCH_ONCE_INLINE_FASTPATH
+DISPATCH_INLINE DISPATCH_ALWAYS_INLINE DISPATCH_NONNULL1 DISPATCH_NONNULL3
+DISPATCH_NOTHROW
+DISPATCH_SWIFT3_UNAVAILABLE("Use lazily initialized globals instead")
+void
+_dispatch_once_f(dispatch_once_t *predicate, void *_Nullable context,
+		dispatch_function_t function)
+{
+	if (DISPATCH_EXPECT(*predicate, ~0l) != ~0l) {
+		dispatch_once_f(predicate, context, function);
+	} else {
+		dispatch_compiler_barrier();
+	}
+	DISPATCH_COMPILER_CAN_ASSUME(*predicate == ~0l);
+}
+#undef dispatch_once_f
+#define dispatch_once_f _dispatch_once_f
+#endif // DISPATCH_ONCE_INLINE_FASTPATH
+
+__END_DECLS
+
+DISPATCH_ASSUME_ABI_SINGLE_END
+DISPATCH_ASSUME_NONNULL_END
+
+#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/dispatch/queue.h b/lib/libc/include/any-macos.13-any/dispatch/queue.h
similarity index 98%
rename from lib/libc/include/x86_64-macos.10-none/dispatch/queue.h
rename to lib/libc/include/any-macos.13-any/dispatch/queue.h
index f644b0266d..6816514dd6 100644
--- a/lib/libc/include/x86_64-macos.10-none/dispatch/queue.h
+++ b/lib/libc/include/any-macos.13-any/dispatch/queue.h
@@ -27,6 +27,7 @@
 #endif
 
 DISPATCH_ASSUME_NONNULL_BEGIN
+DISPATCH_ASSUME_ABI_SINGLE_BEGIN
 
 /*!
  * @header
@@ -336,7 +337,7 @@ dispatch_sync_f(dispatch_queue_t queue,
  * <b>Differences with dispatch_sync()</b>
  *
  * Work items submitted to a queue with dispatch_async_and_wait() observe all
- * queue attributes of that queue when invoked (inluding autorelease frequency
+ * queue attributes of that queue when invoked (including autorelease frequency
  * or QOS class).
  *
  * When the runtime has brought up a thread to invoke the asynchronous workitems
@@ -473,6 +474,9 @@ dispatch_async_and_wait_f(dispatch_queue_t queue,
  * @param block
  * The block to be invoked the specified number of iterations.
  * The result of passing NULL in this parameter is undefined.
+ * This function performs a Block_copy() and Block_release() of the input block
+ * on behalf of the callers. To elide the additional block allocation,
+ * dispatch_apply_f may be used instead.
  */
 #ifdef __BLOCKS__
 API_AVAILABLE(macos(10.6), ios(4.0))
@@ -480,7 +484,7 @@ DISPATCH_EXPORT DISPATCH_NONNULL3 DISPATCH_NOTHROW
 void
 dispatch_apply(size_t iterations,
 		dispatch_queue_t DISPATCH_APPLY_QUEUE_ARG_NULLABILITY queue,
-		DISPATCH_NOESCAPE void (^block)(size_t));
+		DISPATCH_NOESCAPE void (^block)(size_t iteration));
 #endif
 
 /*!
@@ -515,7 +519,7 @@ DISPATCH_EXPORT DISPATCH_NONNULL4 DISPATCH_NOTHROW
 void
 dispatch_apply_f(size_t iterations,
 		dispatch_queue_t DISPATCH_APPLY_QUEUE_ARG_NULLABILITY queue,
-		void *_Nullable context, void (*work)(void *_Nullable, size_t));
+		void *_Nullable context, void (*work)(void *_Nullable context, size_t iteration));
 
 /*!
  * @function dispatch_get_current_queue
@@ -661,7 +665,7 @@ typedef long dispatch_queue_priority_t;
 API_AVAILABLE(macos(10.6), ios(4.0))
 DISPATCH_EXPORT DISPATCH_CONST DISPATCH_WARN_RESULT DISPATCH_NOTHROW
 dispatch_queue_global_t
-dispatch_get_global_queue(long identifier, unsigned long flags);
+dispatch_get_global_queue(intptr_t identifier, uintptr_t flags);
 
 /*!
  * @typedef dispatch_queue_attr_t
@@ -988,7 +992,7 @@ API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
 DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
 DISPATCH_NOTHROW
 dispatch_queue_t
-dispatch_queue_create_with_target(const char *_Nullable label,
+dispatch_queue_create_with_target(const char *_Nullable DISPATCH_UNSAFE_INDEXABLE label,
 		dispatch_queue_attr_t _Nullable attr, dispatch_queue_t _Nullable target)
 		DISPATCH_ALIAS_V2(dispatch_queue_create_with_target);
 
@@ -1023,6 +1027,8 @@ dispatch_queue_create_with_target(const char *_Nullable label,
  * When no quality of service class is specified, the target queue of a newly
  * created dispatch queue is the default priority global concurrent queue.
  *
+ * Unless explicitly specified via the attribute, queues are created active.
+ *
  * @param label
  * A string label to attach to the queue.
  * This parameter is optional and may be NULL.
@@ -1039,7 +1045,7 @@ API_AVAILABLE(macos(10.6), ios(4.0))
 DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
 DISPATCH_NOTHROW
 dispatch_queue_t
-dispatch_queue_create(const char *_Nullable label,
+dispatch_queue_create(const char *_Nullable DISPATCH_UNSAFE_INDEXABLE label,
 		dispatch_queue_attr_t _Nullable attr);
 
 /*!
@@ -1157,7 +1163,9 @@ dispatch_queue_get_qos_class(dispatch_queue_t queue,
  * terminated.
  *
  * If a dispatch queue is active and targeted by other dispatch objects,
- * changing its target queue results in undefined behavior.
+ * changing its target queue results in undefined behavior.  Instead, it is
+ * recommended to create dispatch objects in an inactive state, set up the
+ * relevant target queues and then activate them.
  *
  * @param object
  * The object to modify.
@@ -1669,6 +1677,7 @@ dispatch_assert_queue_not(dispatch_queue_t queue)
 
 __END_DECLS
 
+DISPATCH_ASSUME_ABI_SINGLE_END
 DISPATCH_ASSUME_NONNULL_END
 
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/dispatch/semaphore.h b/lib/libc/include/any-macos.13-any/dispatch/semaphore.h
similarity index 91%
rename from lib/libc/include/x86_64-macos.10-none/dispatch/semaphore.h
rename to lib/libc/include/any-macos.13-any/dispatch/semaphore.h
index 156fb800f3..5de07ba80e 100644
--- a/lib/libc/include/x86_64-macos.10-none/dispatch/semaphore.h
+++ b/lib/libc/include/any-macos.13-any/dispatch/semaphore.h
@@ -27,6 +27,7 @@
 #endif
 
 DISPATCH_ASSUME_NONNULL_BEGIN
+DISPATCH_ASSUME_ABI_SINGLE_BEGIN
 
 /*!
  * @typedef dispatch_semaphore_t
@@ -61,7 +62,7 @@ API_AVAILABLE(macos(10.6), ios(4.0))
 DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
 DISPATCH_NOTHROW
 dispatch_semaphore_t
-dispatch_semaphore_create(long value);
+dispatch_semaphore_create(intptr_t value);
 
 /*!
  * @function dispatch_semaphore_wait
@@ -71,7 +72,9 @@ dispatch_semaphore_create(long value);
  *
  * @discussion
  * Decrement the counting semaphore. If the resulting value is less than zero,
- * this function waits for a signal to occur before returning.
+ * this function waits for a signal to occur before returning. If the timeout is
+ * reached without a signal being received, the semaphore is re-incremented
+ * before the function returns.
  *
  * @param dsema
  * The semaphore. The result of passing NULL in this parameter is undefined.
@@ -85,7 +88,7 @@ dispatch_semaphore_create(long value);
  */
 API_AVAILABLE(macos(10.6), ios(4.0))
 DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-long
+intptr_t
 dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);
 
 /*!
@@ -107,11 +110,12 @@ dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);
  */
 API_AVAILABLE(macos(10.6), ios(4.0))
 DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
-long
+intptr_t
 dispatch_semaphore_signal(dispatch_semaphore_t dsema);
 
 __END_DECLS
 
+DISPATCH_ASSUME_ABI_SINGLE_END
 DISPATCH_ASSUME_NONNULL_END
 
 #endif /* __DISPATCH_SEMAPHORE__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/dispatch/source.h b/lib/libc/include/any-macos.13-any/dispatch/source.h
similarity index 99%
rename from lib/libc/include/x86_64-macos.10-none/dispatch/source.h
rename to lib/libc/include/any-macos.13-any/dispatch/source.h
index 968b9ff89e..d49817c38e 100644
--- a/lib/libc/include/x86_64-macos.10-none/dispatch/source.h
+++ b/lib/libc/include/any-macos.13-any/dispatch/source.h
@@ -36,6 +36,7 @@
 #endif
 
 DISPATCH_ASSUME_NONNULL_BEGIN
+DISPATCH_ASSUME_ABI_SINGLE_BEGIN
 
 /*!
  * @header
@@ -389,7 +390,7 @@ DISPATCH_NOTHROW
 dispatch_source_t
 dispatch_source_create(dispatch_source_type_t type,
 	uintptr_t handle,
-	unsigned long mask,
+	uintptr_t mask,
 	dispatch_queue_t _Nullable queue);
 
 /*!
@@ -537,7 +538,7 @@ dispatch_source_cancel(dispatch_source_t source);
 API_AVAILABLE(macos(10.6), ios(4.0))
 DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_WARN_RESULT DISPATCH_PURE
 DISPATCH_NOTHROW
-long
+intptr_t
 dispatch_source_testcancel(dispatch_source_t source);
 
 /*!
@@ -601,7 +602,7 @@ dispatch_source_get_handle(dispatch_source_t source);
 API_AVAILABLE(macos(10.6), ios(4.0))
 DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_WARN_RESULT DISPATCH_PURE
 DISPATCH_NOTHROW
-unsigned long
+uintptr_t
 dispatch_source_get_mask(dispatch_source_t source);
 
 /*!
@@ -640,7 +641,7 @@ dispatch_source_get_mask(dispatch_source_t source);
 API_AVAILABLE(macos(10.6), ios(4.0))
 DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_WARN_RESULT DISPATCH_PURE
 DISPATCH_NOTHROW
-unsigned long
+uintptr_t
 dispatch_source_get_data(dispatch_source_t source);
 
 /*!
@@ -662,7 +663,7 @@ dispatch_source_get_data(dispatch_source_t source);
 API_AVAILABLE(macos(10.6), ios(4.0))
 DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
 void
-dispatch_source_merge_data(dispatch_source_t source, unsigned long value);
+dispatch_source_merge_data(dispatch_source_t source, uintptr_t value);
 
 /*!
  * @function dispatch_source_set_timer
@@ -775,6 +776,7 @@ dispatch_source_set_registration_handler_f(dispatch_source_t source,
 
 __END_DECLS
 
+DISPATCH_ASSUME_ABI_SINGLE_END
 DISPATCH_ASSUME_NONNULL_END
 
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/dispatch/time.h b/lib/libc/include/any-macos.13-any/dispatch/time.h
new file mode 100644
index 0000000000..281513f387
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/dispatch/time.h
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2008-2011 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __DISPATCH_TIME__
+#define __DISPATCH_TIME__
+
+#ifndef __DISPATCH_INDIRECT__
+#error "Please #include <dispatch/dispatch.h> instead of this file directly."
+#include <dispatch/base.h> // for HeaderDoc
+#endif
+
+#include <stdint.h>
+
+// <rdar://problem/6368156&7563559>
+#if TARGET_OS_MAC
+#include <mach/clock_types.h>
+#endif
+
+DISPATCH_ASSUME_NONNULL_BEGIN
+DISPATCH_ASSUME_ABI_SINGLE_BEGIN
+
+#ifdef NSEC_PER_SEC
+#undef NSEC_PER_SEC
+#endif
+#ifdef USEC_PER_SEC
+#undef USEC_PER_SEC
+#endif
+#ifdef NSEC_PER_USEC
+#undef NSEC_PER_USEC
+#endif
+#ifdef NSEC_PER_MSEC
+#undef NSEC_PER_MSEC
+#endif
+#define NSEC_PER_SEC 1000000000ull
+#define NSEC_PER_MSEC 1000000ull
+#define USEC_PER_SEC 1000000ull
+#define NSEC_PER_USEC 1000ull
+
+__BEGIN_DECLS
+
+struct timespec;
+
+/*!
+ * @typedef dispatch_time_t
+ *
+ * @abstract
+ * A somewhat abstract representation of time; where zero means "now" and
+ * DISPATCH_TIME_FOREVER means "infinity" and every value in between is an
+ * opaque encoding.
+ */
+typedef uint64_t dispatch_time_t;
+
+enum {
+	DISPATCH_WALLTIME_NOW DISPATCH_ENUM_API_AVAILABLE
+			(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))	= ~1ull,
+};
+
+#define DISPATCH_TIME_NOW (0ull)
+#define DISPATCH_TIME_FOREVER (~0ull)
+
+/*!
+ * @function dispatch_time
+ *
+ * @abstract
+ * Create a dispatch_time_t relative to the current value of the default or
+ * wall time clock, or modify an existing dispatch_time_t.
+ *
+ * @discussion
+ * On Apple platforms, the default clock is based on mach_absolute_time().
+ *
+ * @param when
+ * An optional dispatch_time_t to add nanoseconds to. If DISPATCH_TIME_NOW is
+ * passed, then dispatch_time() will use the default clock (which is based on
+ * mach_absolute_time() on Apple platforms). If DISPATCH_WALLTIME_NOW is used,
+ * dispatch_time() will use the value returned by gettimeofday(3).
+ * dispatch_time(DISPATCH_WALLTIME_NOW, delta) is equivalent to
+ * dispatch_walltime(NULL, delta).
+ *
+ * @param delta
+ * Nanoseconds to add.
+ *
+ * @result
+ * A new dispatch_time_t.
+ */
+API_AVAILABLE(macos(10.6), ios(4.0))
+DISPATCH_EXPORT DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_time_t
+dispatch_time(dispatch_time_t when, int64_t delta);
+
+/*!
+ * @function dispatch_walltime
+ *
+ * @abstract
+ * Create a dispatch_time_t using the wall clock.
+ *
+ * @discussion
+ * On Mac OS X the wall clock is based on gettimeofday(3).
+ *
+ * @param when
+ * A struct timespec to add time to. If NULL is passed, then
+ * dispatch_walltime() will use the result of gettimeofday(3).
+ * dispatch_walltime(NULL, delta) returns the same value as
+ * dispatch_time(DISPATCH_WALLTIME_NOW, delta).
+ *
+ * @param delta
+ * Nanoseconds to add.
+ *
+ * @result
+ * A new dispatch_time_t.
+ */
+API_AVAILABLE(macos(10.6), ios(4.0))
+DISPATCH_EXPORT DISPATCH_WARN_RESULT DISPATCH_NOTHROW
+dispatch_time_t
+dispatch_walltime(const struct timespec *_Nullable when, int64_t delta);
+
+__END_DECLS
+
+DISPATCH_ASSUME_ABI_SINGLE_END
+DISPATCH_ASSUME_NONNULL_END
+
+#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/dispatch/workloop.h b/lib/libc/include/any-macos.13-any/dispatch/workloop.h
similarity index 76%
rename from lib/libc/include/x86_64-macos.10-none/dispatch/workloop.h
rename to lib/libc/include/any-macos.13-any/dispatch/workloop.h
index dcd1db43cc..5be010a52a 100644
--- a/lib/libc/include/x86_64-macos.10-none/dispatch/workloop.h
+++ b/lib/libc/include/any-macos.13-any/dispatch/workloop.h
@@ -27,6 +27,7 @@
 #endif
 
 DISPATCH_ASSUME_NONNULL_BEGIN
+DISPATCH_ASSUME_ABI_SINGLE_BEGIN
 
 __BEGIN_DECLS
 
@@ -39,7 +40,9 @@ __BEGIN_DECLS
  * @discussion
  * A dispatch workloop is a flavor of dispatch_queue_t that is a priority
  * ordered queue (using the QOS class of the submitted workitems as the
- * ordering).
+ * ordering). Dispatch workloops are an exclusion context and it is guaranteed
+ * that only one work item submitted to the dispatch workloop will be invoked at
+ * a time.
  *
  * Between each workitem invocation, the workloop will evaluate whether higher
  * priority workitems have since been submitted, either directly to the
@@ -75,7 +78,7 @@ API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
 DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
 DISPATCH_NOTHROW
 dispatch_workloop_t
-dispatch_workloop_create(const char *_Nullable label);
+dispatch_workloop_create(const char *DISPATCH_UNSAFE_INDEXABLE _Nullable label);
 
 /*!
  * @function dispatch_workloop_create_inactive
@@ -101,7 +104,7 @@ API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
 DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
 DISPATCH_NOTHROW
 dispatch_workloop_t
-dispatch_workloop_create_inactive(const char *_Nullable label);
+dispatch_workloop_create_inactive(const char *DISPATCH_UNSAFE_INDEXABLE _Nullable label);
 
 /*!
  * @function dispatch_workloop_set_autorelease_frequency
@@ -129,8 +132,36 @@ void
 dispatch_workloop_set_autorelease_frequency(dispatch_workloop_t workloop,
 		dispatch_autorelease_frequency_t frequency);
 
+/*!
+  * @function dispatch_workloop_set_os_workgroup
+  *
+  * @abstract
+  * Associates an os_workgroup_t with the specified dispatch workloop.
+  *
+  * The worker thread will be a member of the specified os_workgroup_t while executing
+  * work items submitted to the workloop.
+  *
+  * @param workloop
+  * The dispatch workloop to modify.
+  *
+  * This workloop must be inactive, passing an activated object is undefined
+  * and will cause the process to be terminated.
+  *
+  * @param workgroup
+  * The workgroup to associate with this workloop.
+  *
+  * The workgroup specified is retained and the previously associated workgroup
+  * (if any) is released.
+  */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
+void
+dispatch_workloop_set_os_workgroup(dispatch_workloop_t workloop,
+		os_workgroup_t workgroup);
+
 __END_DECLS
 
+DISPATCH_ASSUME_ABI_SINGLE_END
 DISPATCH_ASSUME_NONNULL_END
 
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/dlfcn.h b/lib/libc/include/any-macos.13-any/dlfcn.h
new file mode 100644
index 0000000000..b858a2a294
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/dlfcn.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2004-2008 Apple Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ * 
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ * 
+ * @APPLE_LICENSE_HEADER_END@
+ */
+
+/*
+  Based on the dlcompat work done by:
+		Jorge Acereda  <jacereda@users.sourceforge.net> &
+		Peter O'Gorman <ogorman@users.sourceforge.net>
+*/
+
+#ifndef _DLFCN_H_
+#define _DLFCN_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/cdefs.h>
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+#include <stdbool.h>
+#include <Availability.h>
+
+#ifdef __DRIVERKIT_19_0
+ #define __DYLDDL_DRIVERKIT_UNAVAILABLE __API_UNAVAILABLE(driverkit)
+#else
+ #define __DYLDDL_DRIVERKIT_UNAVAILABLE
+#endif
+
+/*
+ * Structure filled in by dladdr().
+ */
+typedef struct dl_info {
+        const char      *dli_fname;     /* Pathname of shared object */
+        void            *dli_fbase;     /* Base address of shared object */
+        const char      *dli_sname;     /* Name of nearest symbol */
+        void            *dli_saddr;     /* Address of nearest symbol */
+} Dl_info;
+
+extern int dladdr(const void *, Dl_info *);
+#else
+ #define __DYLDDL_DRIVERKIT_UNAVAILABLE
+#endif /* not POSIX */
+
+extern int dlclose(void * __handle) __DYLDDL_DRIVERKIT_UNAVAILABLE;
+extern char * dlerror(void) __DYLDDL_DRIVERKIT_UNAVAILABLE;
+extern void * dlopen(const char * __path, int __mode) __DYLDDL_DRIVERKIT_UNAVAILABLE;
+extern void * dlsym(void * __handle, const char * __symbol);
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+extern bool dlopen_preflight(const char* __path) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0) __DYLDDL_DRIVERKIT_UNAVAILABLE;
+#endif /* not POSIX */
+
+
+#define RTLD_LAZY	0x1
+#define RTLD_NOW	0x2
+#define RTLD_LOCAL	0x4
+#define RTLD_GLOBAL	0x8
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+#define RTLD_NOLOAD	0x10
+#define RTLD_NODELETE	0x80
+#define RTLD_FIRST	0x100	/* Mac OS X 10.5 and later */
+
+/*
+ * Special handle arguments for dlsym().
+ */
+#define	RTLD_NEXT	((void *) -1)	/* Search subsequent objects. */
+#define	RTLD_DEFAULT	((void *) -2)	/* Use default search algorithm. */
+#define	RTLD_SELF	((void *) -3)	/* Search this and subsequent objects (Mac OS X 10.5 and later) */
+#define	RTLD_MAIN_ONLY	((void *) -5)	/* Search main executable only (Mac OS X 10.5 and later) */
+#endif /* not POSIX */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _DLFCN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/launch.h b/lib/libc/include/any-macos.13-any/launch.h
new file mode 100644
index 0000000000..9a1f4853a3
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/launch.h
@@ -0,0 +1,411 @@
+#ifndef __XPC_LAUNCH_H__
+#define __XPC_LAUNCH_H__
+
+/*!
+ * @header
+ * These interfaces were only ever documented for the purpose of allowing a
+ * launchd job to obtain file descriptors associated with the sockets it
+ * advertised in its launchd.plist(5). That functionality is now available in a
+ * much more straightforward fashion through the {@link launch_activate_socket}
+ * API.
+ *
+ * There are currently no replacements for other uses of the {@link launch_msg}
+ * API, including submitting, removing, starting, stopping and listing jobs.
+ */
+
+#include <os/base.h>
+#include <Availability.h>
+
+#include <mach/mach.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <sys/cdefs.h>
+
+#if __has_feature(assume_nonnull)
+_Pragma("clang assume_nonnull begin")
+#endif
+__BEGIN_DECLS
+
+#define LAUNCH_KEY_SUBMITJOB "SubmitJob"
+#define LAUNCH_KEY_REMOVEJOB "RemoveJob"
+#define LAUNCH_KEY_STARTJOB "StartJob"
+#define LAUNCH_KEY_STOPJOB "StopJob"
+#define LAUNCH_KEY_GETJOB "GetJob"
+#define LAUNCH_KEY_GETJOBS "GetJobs"
+#define LAUNCH_KEY_CHECKIN "CheckIn"
+
+#define LAUNCH_JOBKEY_LABEL "Label"
+#define LAUNCH_JOBKEY_DISABLED "Disabled"
+#define LAUNCH_JOBKEY_USERNAME "UserName"
+#define LAUNCH_JOBKEY_GROUPNAME "GroupName"
+#define LAUNCH_JOBKEY_TIMEOUT "TimeOut"
+#define LAUNCH_JOBKEY_EXITTIMEOUT "ExitTimeOut"
+#define LAUNCH_JOBKEY_INITGROUPS "InitGroups"
+#define LAUNCH_JOBKEY_SOCKETS "Sockets"
+#define LAUNCH_JOBKEY_MACHSERVICES "MachServices"
+#define LAUNCH_JOBKEY_MACHSERVICELOOKUPPOLICIES "MachServiceLookupPolicies"
+#define LAUNCH_JOBKEY_INETDCOMPATIBILITY "inetdCompatibility"
+#define LAUNCH_JOBKEY_ENABLEGLOBBING "EnableGlobbing"
+#define LAUNCH_JOBKEY_PROGRAMARGUMENTS "ProgramArguments"
+#define LAUNCH_JOBKEY_PROGRAM "Program"
+#define LAUNCH_JOBKEY_ONDEMAND "OnDemand"
+#define LAUNCH_JOBKEY_KEEPALIVE "KeepAlive"
+#define LAUNCH_JOBKEY_LIMITLOADTOHOSTS "LimitLoadToHosts"
+#define LAUNCH_JOBKEY_LIMITLOADFROMHOSTS "LimitLoadFromHosts"
+#define LAUNCH_JOBKEY_LIMITLOADTOSESSIONTYPE "LimitLoadToSessionType"
+#define LAUNCH_JOBKEY_LIMITLOADTOHARDWARE "LimitLoadToHardware"
+#define LAUNCH_JOBKEY_LIMITLOADFROMHARDWARE "LimitLoadFromHardware"
+#define LAUNCH_JOBKEY_RUNATLOAD "RunAtLoad"
+#define LAUNCH_JOBKEY_ROOTDIRECTORY "RootDirectory"
+#define LAUNCH_JOBKEY_WORKINGDIRECTORY "WorkingDirectory"
+#define LAUNCH_JOBKEY_ENVIRONMENTVARIABLES "EnvironmentVariables"
+#define LAUNCH_JOBKEY_USERENVIRONMENTVARIABLES "UserEnvironmentVariables"
+#define LAUNCH_JOBKEY_UMASK "Umask"
+#define LAUNCH_JOBKEY_NICE "Nice"
+#define LAUNCH_JOBKEY_HOPEFULLYEXITSFIRST "HopefullyExitsFirst"
+#define LAUNCH_JOBKEY_HOPEFULLYEXITSLAST "HopefullyExitsLast"
+#define LAUNCH_JOBKEY_LOWPRIORITYIO "LowPriorityIO"
+#define LAUNCH_JOBKEY_LOWPRIORITYBACKGROUNDIO "LowPriorityBackgroundIO"
+#define LAUNCH_JOBKEY_MATERIALIZEDATALESSFILES "MaterializeDatalessFiles"
+#define LAUNCH_JOBKEY_SESSIONCREATE "SessionCreate"
+#define LAUNCH_JOBKEY_STARTONMOUNT "StartOnMount"
+#define LAUNCH_JOBKEY_SOFTRESOURCELIMITS "SoftResourceLimits"
+#define LAUNCH_JOBKEY_HARDRESOURCELIMITS "HardResourceLimits"
+#define LAUNCH_JOBKEY_STANDARDINPATH "StandardInPath"
+#define LAUNCH_JOBKEY_STANDARDOUTPATH "StandardOutPath"
+#define LAUNCH_JOBKEY_STANDARDERRORPATH "StandardErrorPath"
+#define LAUNCH_JOBKEY_DEBUG "Debug"
+#define LAUNCH_JOBKEY_WAITFORDEBUGGER "WaitForDebugger"
+#define LAUNCH_JOBKEY_QUEUEDIRECTORIES "QueueDirectories"
+#define LAUNCH_JOBKEY_HOMERELATIVEQUEUEDIRECTORIES "HomeRelativeQueueDirectories"
+#define LAUNCH_JOBKEY_WATCHPATHS "WatchPaths"
+#define LAUNCH_JOBKEY_STARTINTERVAL "StartInterval"
+#define LAUNCH_JOBKEY_STARTCALENDARINTERVAL "StartCalendarInterval"
+#define LAUNCH_JOBKEY_BONJOURFDS "BonjourFDs"
+#define LAUNCH_JOBKEY_LASTEXITSTATUS "LastExitStatus"
+#define LAUNCH_JOBKEY_PID "PID"
+#define LAUNCH_JOBKEY_THROTTLEINTERVAL "ThrottleInterval"
+#define LAUNCH_JOBKEY_LAUNCHONLYONCE "LaunchOnlyOnce"
+#define LAUNCH_JOBKEY_ABANDONPROCESSGROUP "AbandonProcessGroup"
+#define LAUNCH_JOBKEY_IGNOREPROCESSGROUPATSHUTDOWN \
+	"IgnoreProcessGroupAtShutdown"
+#define LAUNCH_JOBKEY_LEGACYTIMERS "LegacyTimers"
+#define LAUNCH_JOBKEY_ENABLEPRESSUREDEXIT "EnablePressuredExit"
+#define LAUNCH_JOBKEY_ENABLETRANSACTIONS "EnableTransactions"
+#define LAUNCH_JOBKEY_DRAINMESSAGESONFAILEDINIT "DrainMessagesOnFailedInit"
+#define LAUNCH_JOBKEY_POLICIES "Policies"
+#define LAUNCH_JOBKEY_BUNDLEPROGRAM "BundleProgram"
+#define LAUNCH_JOBKEY_ASSOCIATEDBUNDLEIDENTIFIERS "AssociatedBundleIdentifiers"
+
+#define LAUNCH_JOBKEY_PUBLISHESEVENTS "PublishesEvents"
+#define LAUNCH_KEY_PUBLISHESEVENTS_DOMAININTERNAL "DomainInternal"
+
+#define LAUNCH_JOBPOLICY_DENYCREATINGOTHERJOBS "DenyCreatingOtherJobs"
+
+#define LAUNCH_JOBINETDCOMPATIBILITY_WAIT "Wait"
+#define LAUNCH_JOBINETDCOMPATIBILITY_INSTANCES "Instances"
+
+#define LAUNCH_JOBKEY_MACH_RESETATCLOSE "ResetAtClose"
+#define LAUNCH_JOBKEY_MACH_HIDEUNTILCHECKIN "HideUntilCheckIn"
+
+#define LAUNCH_JOBKEY_KEEPALIVE_SUCCESSFULEXIT "SuccessfulExit"
+#define LAUNCH_JOBKEY_KEEPALIVE_NETWORKSTATE "NetworkState"
+#define LAUNCH_JOBKEY_KEEPALIVE_PATHSTATE "PathState"
+#define LAUNCH_JOBKEY_KEEPALIVE_HOMERELATIVEPATHSTATE "HomeRelativePathState"
+#define LAUNCH_JOBKEY_KEEPALIVE_OTHERJOBACTIVE "OtherJobActive"
+#define LAUNCH_JOBKEY_KEEPALIVE_OTHERJOBENABLED "OtherJobEnabled"
+#define LAUNCH_JOBKEY_KEEPALIVE_AFTERINITIALDEMAND	"AfterInitialDemand"
+#define LAUNCH_JOBKEY_KEEPALIVE_CRASHED "Crashed"
+
+#define LAUNCH_JOBKEY_LAUNCHEVENTS "LaunchEvents"
+
+#define LAUNCH_JOBKEY_CAL_MINUTE "Minute"
+#define LAUNCH_JOBKEY_CAL_HOUR "Hour"
+#define LAUNCH_JOBKEY_CAL_DAY "Day"
+#define LAUNCH_JOBKEY_CAL_WEEKDAY "Weekday"
+#define LAUNCH_JOBKEY_CAL_MONTH "Month"
+
+#define LAUNCH_JOBKEY_RESOURCELIMIT_CORE "Core"
+#define LAUNCH_JOBKEY_RESOURCELIMIT_CPU "CPU"
+#define LAUNCH_JOBKEY_RESOURCELIMIT_DATA "Data"
+#define LAUNCH_JOBKEY_RESOURCELIMIT_FSIZE "FileSize"
+#define LAUNCH_JOBKEY_RESOURCELIMIT_MEMLOCK "MemoryLock"
+#define LAUNCH_JOBKEY_RESOURCELIMIT_NOFILE "NumberOfFiles"
+#define LAUNCH_JOBKEY_RESOURCELIMIT_NPROC "NumberOfProcesses"
+#define LAUNCH_JOBKEY_RESOURCELIMIT_RSS "ResidentSetSize"
+#define LAUNCH_JOBKEY_RESOURCELIMIT_STACK "Stack"
+
+#define LAUNCH_JOBKEY_DISABLED_MACHINETYPE "MachineType"
+#define LAUNCH_JOBKEY_DISABLED_MODELNAME "ModelName"
+
+#define LAUNCH_JOBKEY_DATASTORES "Datastores"
+#define LAUNCH_JOBKEY_DATASTORES_SIZELIMIT "SizeLimit"
+
+#define LAUNCH_JOBSOCKETKEY_TYPE "SockType"
+#define LAUNCH_JOBSOCKETKEY_PASSIVE "SockPassive"
+#define LAUNCH_JOBSOCKETKEY_BONJOUR "Bonjour"
+#define LAUNCH_JOBSOCKETKEY_SECUREWITHKEY "SecureSocketWithKey"
+#define LAUNCH_JOBSOCKETKEY_PATHNAME "SockPathName"
+#define LAUNCH_JOBSOCKETKEY_PATHMODE "SockPathMode"
+#define LAUNCH_JOBSOCKETKEY_PATHOWNER "SockPathOwner"
+#define LAUNCH_JOBSOCKETKEY_PATHGROUP "SockPathGroup"
+#define LAUNCH_JOBSOCKETKEY_NODENAME "SockNodeName"
+#define LAUNCH_JOBSOCKETKEY_SERVICENAME "SockServiceName"
+#define LAUNCH_JOBSOCKETKEY_FAMILY "SockFamily"
+#define LAUNCH_JOBSOCKETKEY_PROTOCOL "SockProtocol"
+#define LAUNCH_JOBSOCKETKEY_MULTICASTGROUP "MulticastGroup"
+
+#define LAUNCH_JOBKEY_PROCESSTYPE "ProcessType"
+#define LAUNCH_KEY_PROCESSTYPE_APP "App"
+#define LAUNCH_KEY_PROCESSTYPE_STANDARD "Standard"
+#define LAUNCH_KEY_PROCESSTYPE_BACKGROUND "Background"
+#define LAUNCH_KEY_PROCESSTYPE_INTERACTIVE "Interactive"
+#define LAUNCH_KEY_PROCESSTYPE_ADAPTIVE "Adaptive"
+
+/*!
+ * @function launch_activate_socket
+ *
+ * @abstract
+ * Retrieves the file descriptors for sockets specified in the process'
+ * launchd.plist(5).
+ *
+ * @param name
+ * The name of the socket entry in the service's Sockets dictionary.
+ *
+ * @param fds
+ * On return, this parameter will be populated with an array of file
+ * descriptors. One socket can have many descriptors associated with it
+ * depending on the characteristics of the network interfaces on the system.
+ * The descriptors in this array are the results of calling getaddrinfo(3) with
+ * the parameters described in launchd.plist(5).
+ *
+ * The caller is responsible for calling free(3) on the returned pointer.
+ *
+ * @param cnt
+ * The number of file descriptor entries in the returned array.
+ *
+ * @result
+ * On success, zero is returned. Otherwise, an appropriate POSIX-domain is
+ * returned. Possible error codes are:
+ *
+ * ENOENT -> There was no socket of the specified name owned by the caller.
+ * ESRCH -> The caller is not a process managed by launchd.
+ * EALREADY -> The socket has already been activated by the caller.
+ */
+__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1 OS_NONNULL2 OS_NONNULL3
+int
+launch_activate_socket(const char *name,
+	int * _Nonnull * _Nullable fds, size_t *cnt);
+
+typedef struct _launch_data *launch_data_t;
+typedef void (*launch_data_dict_iterator_t)(const launch_data_t lval,
+	const char *key, void * _Nullable ctx);
+
+typedef enum {
+	LAUNCH_DATA_DICTIONARY = 1,
+	LAUNCH_DATA_ARRAY,
+	LAUNCH_DATA_FD,
+	LAUNCH_DATA_INTEGER,
+	LAUNCH_DATA_REAL,
+	LAUNCH_DATA_BOOL,
+	LAUNCH_DATA_STRING,
+	LAUNCH_DATA_OPAQUE,
+	LAUNCH_DATA_ERRNO,
+	LAUNCH_DATA_MACHPORT,
+} launch_data_type_t;
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_MALLOC OS_WARN_RESULT
+launch_data_t
+launch_data_alloc(launch_data_type_t type);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_MALLOC OS_WARN_RESULT OS_NONNULL1
+launch_data_t
+launch_data_copy(launch_data_t ld);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1
+launch_data_type_t
+launch_data_get_type(const launch_data_t ld);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_NONNULL1
+void
+launch_data_free(launch_data_t ld);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_NONNULL1 OS_NONNULL2 OS_NONNULL3
+bool
+launch_data_dict_insert(launch_data_t ldict, const launch_data_t lval,
+	const char *key);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1 OS_NONNULL2
+launch_data_t _Nullable
+launch_data_dict_lookup(const launch_data_t ldict, const char *key);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_NONNULL1 OS_NONNULL2
+bool
+launch_data_dict_remove(launch_data_t ldict, const char *key);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_NONNULL1 OS_NONNULL2
+void
+launch_data_dict_iterate(const launch_data_t ldict,
+	launch_data_dict_iterator_t iterator, void * _Nullable ctx);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1
+size_t
+launch_data_dict_get_count(const launch_data_t ldict);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_NONNULL1 OS_NONNULL2
+bool
+launch_data_array_set_index(launch_data_t larray, const launch_data_t lval,
+	size_t idx);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1
+launch_data_t
+launch_data_array_get_index(const launch_data_t larray, size_t idx);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1
+size_t
+launch_data_array_get_count(const launch_data_t larray);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_MALLOC OS_WARN_RESULT
+launch_data_t
+launch_data_new_fd(int fd);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_MALLOC OS_WARN_RESULT
+launch_data_t
+launch_data_new_machport(mach_port_t val);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_MALLOC OS_WARN_RESULT
+launch_data_t
+launch_data_new_integer(long long val);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_MALLOC OS_WARN_RESULT
+launch_data_t
+launch_data_new_bool(bool val);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_MALLOC OS_WARN_RESULT
+launch_data_t
+launch_data_new_real(double val);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_MALLOC OS_WARN_RESULT
+launch_data_t
+launch_data_new_string(const char *val);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_MALLOC OS_WARN_RESULT
+launch_data_t
+launch_data_new_opaque(const void *bytes, size_t sz);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_NONNULL1
+bool
+launch_data_set_fd(launch_data_t ld, int fd);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_NONNULL1
+bool
+launch_data_set_machport(launch_data_t ld, mach_port_t mp);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_NONNULL1
+bool
+launch_data_set_integer(launch_data_t ld, long long val);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_NONNULL1
+bool
+launch_data_set_bool(launch_data_t ld, bool val);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_NONNULL1
+bool
+launch_data_set_real(launch_data_t ld, double val);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_NONNULL1
+bool
+launch_data_set_string(launch_data_t ld, const char *val);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_NONNULL1
+bool
+launch_data_set_opaque(launch_data_t ld, const void *bytes, size_t sz);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1
+int
+launch_data_get_fd(const launch_data_t ld);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1
+mach_port_t
+launch_data_get_machport(const launch_data_t ld);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1
+long long
+launch_data_get_integer(const launch_data_t ld);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1
+bool
+launch_data_get_bool(const launch_data_t ld);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1
+double
+launch_data_get_real(const launch_data_t ld);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1
+const char *
+launch_data_get_string(const launch_data_t ld);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1
+void * _Nullable
+launch_data_get_opaque(const launch_data_t ld);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1
+size_t
+launch_data_get_opaque_size(const launch_data_t ld);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT OS_NONNULL1
+int
+launch_data_get_errno(const launch_data_t ld);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_WARN_RESULT
+int
+launch_get_fd(void);
+
+__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_4, __MAC_10_10, __IPHONE_2_0, __IPHONE_8_0)
+OS_EXPORT OS_MALLOC OS_WARN_RESULT OS_NONNULL1
+launch_data_t
+launch_msg(const launch_data_t request);
+
+__END_DECLS
+#if __has_feature(assume_nonnull)
+_Pragma("clang assume_nonnull end")
+#endif
+
+#endif // __XPC_LAUNCH_H__
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/libproc.h b/lib/libc/include/any-macos.13-any/libproc.h
similarity index 79%
rename from lib/libc/include/x86_64-macos.10-none/libproc.h
rename to lib/libc/include/any-macos.13-any/libproc.h
index 757ac08e23..7bb9e0c23a 100644
--- a/lib/libc/include/x86_64-macos.10-none/libproc.h
+++ b/lib/libc/include/any-macos.13-any/libproc.h
@@ -31,10 +31,12 @@
 #include <sys/resource.h>
 #include <stdint.h>
 #include <stdbool.h>
+#include <mach/message.h> /* for audit_token_t */
 
 #include <sys/proc_info.h>
 
 #include <Availability.h>
+#include <os/availability.h>
 
 /*
  * This header file contains private interfaces to obtain process information.
@@ -98,6 +100,7 @@ int proc_name(int pid, void * buffer, uint32_t buffersize) __OSX_AVAILABLE_START
 int proc_regionfilename(int pid, uint64_t address, void * buffer, uint32_t buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
 int proc_kmsgbuf(void * buffer, uint32_t buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
 int proc_pidpath(int pid, void * buffer, uint32_t  buffersize) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
+int proc_pidpath_audittoken(audit_token_t *audittoken, void * buffer, uint32_t  buffersize) API_AVAILABLE(macos(11.0), ios(14.0), watchos(7.0), tvos(14.0));
 int proc_libversion(int *major, int * minor) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
 
 /*
@@ -125,28 +128,46 @@ int proc_get_dirty(pid_t pid, uint32_t *flags);
 int proc_clear_dirty(pid_t pid, uint32_t flags);
 
 int proc_terminate(pid_t pid, int *sig);
+int proc_terminate_all_rsr(int sig);
 
-#ifdef PRIVATE
-#include <sys/event.h>
 /*
- * Enumerate potential userspace pointers embedded in kernel data structures.
- * Currently inspects kqueues only.
+ * NO_SMT means that on an SMT CPU, this thread must be scheduled alone,
+ * with the paired CPU idle.
  *
- * NOTE: returned "pointers" are opaque user-supplied values and thus not
- * guaranteed to address valid objects or be pointers at all.
- *
- * Returns the number of pointers found (which may exceed buffersize), or -1 on
- * failure and errno set appropriately.
+ * Set NO_SMT on the current proc (all existing and future threads)
+ * This attribute is inherited on fork and exec
  */
-int proc_list_uptrs(pid_t pid, uint64_t *buffer, uint32_t buffersize);
+int proc_set_no_smt(void) __API_AVAILABLE(macos(11.0));
 
-int proc_list_dynkqueueids(int pid, kqueue_id_t *buf, uint32_t bufsz);
-int proc_piddynkqueueinfo(int pid, int flavor, kqueue_id_t kq_id, void *buffer,
-    int buffersize);
-#endif /* PRIVATE */
+/* Set NO_SMT on the current thread */
+int proc_setthread_no_smt(void) __API_AVAILABLE(macos(11.0));
+
+/*
+ * CPU Security Mitigation APIs
+ *
+ * Set CPU security mitigation on the current proc (all existing and future threads)
+ * This attribute is inherited on fork and exec
+ */
+int proc_set_csm(uint32_t flags) __API_AVAILABLE(macos(11.0));
+
+/* Set CPU security mitigation on the current thread */
+int proc_setthread_csm(uint32_t flags) __API_AVAILABLE(macos(11.0));
+
+/*
+ * flags for CPU Security Mitigation APIs
+ * PROC_CSM_ALL should be used in most cases,
+ * the individual flags are provided only for performance evaluation etc
+ */
+#define PROC_CSM_ALL         0x0001  /* Set all available mitigations */
+#define PROC_CSM_NOSMT       0x0002  /* Set NO_SMT - see above */
+#define PROC_CSM_TECS        0x0004  /* Execute VERW on every return to user mode */
 
 int proc_udata_info(int pid, int flavor, void *buffer, int buffersize);
 
+#if __has_include(<libproc_private.h>)
+#include <libproc_private.h>
+#endif
+
 __END_DECLS
 
 #endif /*_LIBPROC_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/mach-o/arch.h b/lib/libc/include/any-macos.13-any/mach-o/arch.h
new file mode 100644
index 0000000000..0899e050ad
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/mach-o/arch.h
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ * 
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ * 
+ * @APPLE_LICENSE_HEADER_END@
+ */
+#ifndef _MACH_O_ARCH_H_
+#define _MACH_O_ARCH_H_
+/*
+ * Copyright (c) 1997 Apple Computer, Inc.
+ *
+ * Functions that deal with information about architectures.
+ *
+ */
+
+#include <stdint.h>
+#include <mach/machine.h>
+#include <architecture/byte_order.h>
+#include <Availability.h>
+#include <TargetConditionals.h>
+
+#ifndef __CCTOOLS_DEPRECATED
+    #define __CCTOOLS_DEPRECATED            __API_DEPRECATED("No longer supported", macos(10.0, 13.0), ios(1.0, 16.0), watchos(1.0, 8.0), tvos(1.0, 16.0))
+    #define __CCTOOLS_DEPRECATED_MSG(_msg)  __API_DEPRECATED_WITH_REPLACEMENT(_msg, macos(10.0, 13.0), ios(1.0, 16.0), watchos(1.0, 8.0), tvos(1.0, 16.0))
+#endif
+
+/* The NXArchInfo structs contain the architectures symbolic name
+ * (such as "ppc"), its CPU type and CPU subtype as defined in
+ * mach/machine.h, the byte order for the architecture, and a
+ * describing string (such as "PowerPC").
+ * There will both be entries for specific CPUs (such as ppc604e) as
+ * well as generic "family" entries (such as ppc).
+ */
+
+struct NXArchInfo  {
+    const char *name;
+    cpu_type_t cputype;
+    cpu_subtype_t cpusubtype;
+    enum NXByteOrder byteorder;
+    const char *description;
+} __CCTOOLS_DEPRECATED;
+typedef struct NXArchInfo NXArchInfo __CCTOOLS_DEPRECATED;
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/* NXGetAllArchInfos() returns a pointer to an array of all known
+ * NXArchInfo structures.  The last NXArchInfo is marked by a NULL name.
+ */
+extern const NXArchInfo *NXGetAllArchInfos(void) __CCTOOLS_DEPRECATED;
+
+/* NXGetLocalArchInfo() returns the NXArchInfo for the local host, or NULL
+ * if none is known. 
+ */
+extern const NXArchInfo *NXGetLocalArchInfo(void) __CCTOOLS_DEPRECATED_MSG("use macho_arch_name_for_mach_header()");
+
+/* NXGetArchInfoFromName() and NXGetArchInfoFromCpuType() return the
+ * NXArchInfo from the architecture's name or cputype/cpusubtype
+ * combination.  A cpusubtype of CPU_SUBTYPE_MULTIPLE can be used
+ * to request the most general NXArchInfo known for the given cputype.
+ * NULL is returned if no matching NXArchInfo can be found.
+ */
+extern const NXArchInfo *NXGetArchInfoFromName(const char *name) __CCTOOLS_DEPRECATED_MSG("use macho_cpu_type_for_arch_name()");
+extern const NXArchInfo *NXGetArchInfoFromCpuType(cpu_type_t cputype,
+						  cpu_subtype_t cpusubtype) __CCTOOLS_DEPRECATED_MSG("use macho_arch_name_for_cpu_type()");
+
+/* The above interfaces that return pointers to NXArchInfo structs in normal
+ * cases returns a pointer from the array returned in NXGetAllArchInfos().
+ * In some cases when the cputype is CPU_TYPE_I386 or CPU_TYPE_POWERPC it will
+ * retun malloc(3)'ed NXArchInfo struct which contains a string in the
+ * description field also a malloc(3)'ed pointer.  To allow programs not to
+ * leak memory they can call NXFreeArchInfo() on pointers returned from the
+ * above interfaces.  Since this is a new API on older systems can use the
+ * code below.  Going forward the above interfaces will only return pointers
+ * from the array returned in NXGetAllArchInfos().
+ */
+extern void NXFreeArchInfo(const NXArchInfo *x) __CCTOOLS_DEPRECATED_MSG("NXArchInfo is deprecated");
+
+/* The code that can be used for NXFreeArchInfo() when it is not available is:
+ *
+ *	static void NXFreeArchInfo(
+ *	const NXArchInfo *x)
+ *	{
+ *	    const NXArchInfo *p;
+ *	
+ *	        p = NXGetAllArchInfos();
+ *	        while(p->name != NULL){
+ *	            if(x == p)
+ *	                return;
+ *	            p++;
+ *	        }
+ *	        free((char *)x->description);
+ *	        free((NXArchInfo *)x);
+ *	}
+ */
+
+/* NXFindBestFatArch() is passed a cputype and cpusubtype and a set of
+ * fat_arch structs and selects the best one that matches (if any) and returns
+ * a pointer to that fat_arch struct (or NULL).  The fat_arch structs must be
+ * in the host byte order and correct such that the fat_archs really points to
+ * enough memory for nfat_arch structs.  It is possible that this routine could
+ * fail if new cputypes or cpusubtypes are added and an old version of this
+ * routine is used.  But if there is an exact match between the cputype and
+ * cpusubtype and one of the fat_arch structs this routine will always succeed.
+ */
+extern struct fat_arch *NXFindBestFatArch(cpu_type_t cputype,
+					  cpu_subtype_t cpusubtype,
+					  struct fat_arch *fat_archs,
+					  uint32_t nfat_archs) __CCTOOLS_DEPRECATED_MSG("use macho_best_slice()");
+
+/* NXFindBestFatArch_64() is passed a cputype and cpusubtype and a set of
+ * fat_arch_64 structs and selects the best one that matches (if any) and
+ * returns a pointer to that fat_arch_64 struct (or NULL).  The fat_arch_64
+ * structs must be in the host byte order and correct such that the fat_archs64
+ * really points to enough memory for nfat_arch structs.  It is possible that
+ * this routine could fail if new cputypes or cpusubtypes are added and an old
+ * version of this routine is used.  But if there is an exact match between the
+ * cputype and cpusubtype and one of the fat_arch_64 structs this routine will
+ * always succeed.
+ */
+extern struct fat_arch_64 *NXFindBestFatArch_64(cpu_type_t cputype,
+					        cpu_subtype_t cpusubtype,
+					        struct fat_arch_64 *fat_archs64,
+					        uint32_t nfat_archs) __CCTOOLS_DEPRECATED_MSG("use macho_best_slice()");
+
+/* NXCombineCpuSubtypes() returns the resulting cpusubtype when combining two
+ * different cpusubtypes for the specified cputype.  If the two cpusubtypes
+ * can't be combined (the specific subtypes are mutually exclusive) -1 is
+ * returned indicating it is an error to combine them.  This can also fail and
+ * return -1 if new cputypes or cpusubtypes are added and an old version of
+ * this routine is used.  But if the cpusubtypes are the same they can always
+ * be combined and this routine will return the cpusubtype pass in.
+ */
+extern cpu_subtype_t NXCombineCpuSubtypes(cpu_type_t cputype,
+					  cpu_subtype_t cpusubtype1,
+					  cpu_subtype_t cpusubtype2) __CCTOOLS_DEPRECATED_MSG("cpu subtypes are no longer combinable");
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* _MACH_O_ARCH_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/mach-o/fat.h b/lib/libc/include/any-macos.13-any/mach-o/fat.h
new file mode 100644
index 0000000000..32959ca42a
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/mach-o/fat.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2016 Apple, Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ * 
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ * 
+ * @APPLE_LICENSE_HEADER_END@
+ */
+#ifndef _MACH_O_FAT_H_
+#define _MACH_O_FAT_H_
+/*
+ * This header file describes the structures of the file format for "fat"
+ * architecture specific file (wrapper design).  At the begining of the file
+ * there is one fat_header structure followed by a number of fat_arch
+ * structures.  For each architecture in the file, specified by a pair of
+ * cputype and cpusubtype, the fat_header describes the file offset, file
+ * size and alignment in the file of the architecture specific member.
+ * The padded bytes in the file to place each member on it's specific alignment
+ * are defined to be read as zeros and can be left as "holes" if the file system
+ * can support them as long as they read as zeros.
+ *
+ * All structures defined here are always written and read to/from disk
+ * in big-endian order.
+ */
+
+/*
+ * <mach/machine.h> is needed here for the cpu_type_t and cpu_subtype_t types
+ * and contains the constants for the possible values of these types.
+ */
+#include <stdint.h>
+#include <mach/machine.h>
+
+#if __has_include(<architecture/byte_order.h>)
+#include <architecture/byte_order.h>
+#endif
+
+#define FAT_MAGIC	0xcafebabe
+#define FAT_CIGAM	0xbebafeca	/* NXSwapLong(FAT_MAGIC) */
+
+struct fat_header {
+	uint32_t	magic;		/* FAT_MAGIC or FAT_MAGIC_64 */
+	uint32_t	nfat_arch;	/* number of structs that follow */
+};
+
+struct fat_arch {
+	cpu_type_t	cputype;	/* cpu specifier (int) */
+	cpu_subtype_t	cpusubtype;	/* machine specifier (int) */
+	uint32_t	offset;		/* file offset to this object file */
+	uint32_t	size;		/* size of this object file */
+	uint32_t	align;		/* alignment as a power of 2 */
+};
+
+/*
+ * The support for the 64-bit fat file format described here is a work in
+ * progress and not yet fully supported in all the Apple Developer Tools.
+ *
+ * When a slice is greater than 4mb or an offset to a slice is greater than 4mb
+ * then the 64-bit fat file format is used.
+ */
+#define FAT_MAGIC_64	0xcafebabf
+#define FAT_CIGAM_64	0xbfbafeca	/* NXSwapLong(FAT_MAGIC_64) */
+
+struct fat_arch_64 {
+	cpu_type_t	cputype;	/* cpu specifier (int) */
+	cpu_subtype_t	cpusubtype;	/* machine specifier (int) */
+	uint64_t	offset;		/* file offset to this object file */
+	uint64_t	size;		/* size of this object file */
+	uint32_t	align;		/* alignment as a power of 2 */
+	uint32_t	reserved;	/* reserved */
+};
+
+#endif /* _MACH_O_FAT_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach-o/loader.h b/lib/libc/include/any-macos.13-any/mach-o/loader.h
similarity index 96%
rename from lib/libc/include/x86_64-macos.10-none/mach-o/loader.h
rename to lib/libc/include/any-macos.13-any/mach-o/loader.h
index a088105205..4ffc5140a3 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach-o/loader.h
+++ b/lib/libc/include/any-macos.13-any/mach-o/loader.h
@@ -32,20 +32,28 @@
  * <mach/machine.h> is needed here for the cpu_type_t and cpu_subtype_t types
  * and contains the constants for the possible values of these types.
  */
+#if __has_include(<mach/machine.h>)
 #include <mach/machine.h>
+#endif
 
 /*
  * <mach/vm_prot.h> is needed here for the vm_prot_t type and contains the 
  * constants that are or'ed together for the possible values of this type.
  */
+#if __has_include(<mach/vm_prot.h>)
 #include <mach/vm_prot.h>
+#endif
 
 /*
  * <machine/thread_status.h> is expected to define the flavors of the thread
  * states and the structures of those flavors for each machine.
  */
+#if __has_include(<mach/machine/thread_status.h>)
 #include <mach/machine/thread_status.h>
+#endif
+#if __has_include(<architecture/byte_order.h>)
 #include <architecture/byte_order.h>
+#endif
 
 /*
  * The 32-bit mach header appears at the very beginning of the object file for
@@ -53,8 +61,8 @@
  */
 struct mach_header {
 	uint32_t	magic;		/* mach magic number identifier */
-	cpu_type_t	cputype;	/* cpu specifier */
-	cpu_subtype_t	cpusubtype;	/* machine specifier */
+	int32_t		cputype;	/* cpu specifier */
+	int32_t		cpusubtype;	/* machine specifier */
 	uint32_t	filetype;	/* type of file */
 	uint32_t	ncmds;		/* number of load commands */
 	uint32_t	sizeofcmds;	/* the size of all the load commands */
@@ -71,8 +79,8 @@ struct mach_header {
  */
 struct mach_header_64 {
 	uint32_t	magic;		/* mach magic number identifier */
-	cpu_type_t	cputype;	/* cpu specifier */
-	cpu_subtype_t	cpusubtype;	/* machine specifier */
+	int32_t		cputype;	/* cpu specifier */
+	int32_t		cpusubtype;	/* machine specifier */
 	uint32_t	filetype;	/* type of file */
 	uint32_t	ncmds;		/* number of load commands */
 	uint32_t	sizeofcmds;	/* the size of all the load commands */
@@ -115,11 +123,17 @@ struct mach_header_64 {
 #define	MH_DYLIB	0x6		/* dynamically bound shared library */
 #define	MH_DYLINKER	0x7		/* dynamic link editor */
 #define	MH_BUNDLE	0x8		/* dynamically bound bundle file */
-#define	MH_DYLIB_STUB	0x9		/* shared library stub for static */
-					/*  linking only, no section contents */
-#define	MH_DSYM		0xa		/* companion file with only debug */
-					/*  sections */
+#define	MH_DYLIB_STUB	0x9		/* shared library stub for static
+					   linking only, no section contents */
+#define	MH_DSYM		0xa		/* companion file with only debug
+					   sections */
 #define	MH_KEXT_BUNDLE	0xb		/* x86_64 kexts */
+#define MH_FILESET	0xc		/* a file composed of other Mach-Os to
+					   be run in the same userspace sharing
+					   a single linkedit. */
+#define	MH_GPU_EXECUTE	0xd		/* gpu program */
+#define	MH_GPU_DYLIB	0xe		/* gpu support functions */
+
 
 /* Constants for the flags field of the mach_header */
 #define	MH_NOUNDEFS	0x1		/* the object file has no undefined
@@ -322,6 +336,7 @@ struct load_command {
 #define LC_BUILD_VERSION 0x32 /* build for platform min OS version */
 #define LC_DYLD_EXPORTS_TRIE (0x33 | LC_REQ_DYLD) /* used with linkedit_data_command, payload is trie */
 #define LC_DYLD_CHAINED_FIXUPS (0x34 | LC_REQ_DYLD) /* used with linkedit_data_command */
+#define LC_FILESET_ENTRY (0x35 | LC_REQ_DYLD) /* used with fileset_entry_command */
 
 /*
  * A variable length string in a load command is represented by an lc_str
@@ -358,8 +373,8 @@ struct segment_command { /* for 32-bit architectures */
 	uint32_t	vmsize;		/* memory size of this segment */
 	uint32_t	fileoff;	/* file offset of this segment */
 	uint32_t	filesize;	/* amount to map from the file */
-	vm_prot_t	maxprot;	/* maximum VM protection */
-	vm_prot_t	initprot;	/* initial VM protection */
+	int32_t		maxprot;	/* maximum VM protection */
+	int32_t		initprot;	/* initial VM protection */
 	uint32_t	nsects;		/* number of sections in segment */
 	uint32_t	flags;		/* flags */
 };
@@ -378,8 +393,8 @@ struct segment_command_64 { /* for 64-bit architectures */
 	uint64_t	vmsize;		/* memory size of this segment */
 	uint64_t	fileoff;	/* file offset of this segment */
 	uint64_t	filesize;	/* amount to map from the file */
-	vm_prot_t	maxprot;	/* maximum VM protection */
-	vm_prot_t	initprot;	/* initial VM protection */
+	int32_t		maxprot;	/* maximum VM protection */
+	int32_t		initprot;	/* initial VM protection */
 	uint32_t	nsects;		/* number of sections in segment */
 	uint32_t	flags;		/* flags */
 };
@@ -1259,24 +1274,45 @@ struct build_tool_version {
 };
 
 /* Known values for the platform field above. */
+#define PLATFORM_UNKNOWN 0
+#define PLATFORM_ANY 0xFFFFFFFF
 #define PLATFORM_MACOS 1
 #define PLATFORM_IOS 2
 #define PLATFORM_TVOS 3
 #define PLATFORM_WATCHOS 4
 #define PLATFORM_BRIDGEOS 5
 #define PLATFORM_MACCATALYST 6
-#if (!defined(PLATFORM_MACCATALYST))
-#define PLATFORM_MACCATALYST 6
-#endif
 #define PLATFORM_IOSSIMULATOR 7
 #define PLATFORM_TVOSSIMULATOR 8
 #define PLATFORM_WATCHOSSIMULATOR 9
 #define PLATFORM_DRIVERKIT 10
 
+#ifndef __OPEN_SOURCE__
+
+#endif /* __OPEN_SOURCE__ */
+
+#define PLATFORM_FIRMWARE 13
+#define PLATFORM_SEPOS 14
+
+#ifndef __OPEN_SOURCE__
+
+#endif /* __OPEN_SOURCE__ */
+
 /* Known values for the tool field above. */
 #define TOOL_CLANG 1
 #define TOOL_SWIFT 2
 #define TOOL_LD	3
+#define TOOL_LLD 4
+
+/* values for gpu tools (1024 to 1048) */
+#define TOOL_METAL                 1024
+#define TOOL_AIRLLD                1025
+#define TOOL_AIRNT                 1026
+#define TOOL_AIRNT_PLUGIN          1027
+#define TOOL_AIRPACK               1028
+#define TOOL_GPUARCHIVER           1031
+#define TOOL_METAL_FRAMEWORK       1032
+
 
 /*
  * The dyld_info_command contains the file offsets and sizes of 
@@ -1455,6 +1491,8 @@ struct dyld_info_command {
 #define EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION			0x04
 #define EXPORT_SYMBOL_FLAGS_REEXPORT				0x08
 #define EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER			0x10
+#define EXPORT_SYMBOL_FLAGS_STATIC_RESOLVER			0x20
+
 
 /*
  * The linker_option_command contains linker options embedded in object files.
@@ -1574,4 +1612,27 @@ struct note_command {
     uint64_t	size;		/* length of data region */
 };
 
+/*
+ * LC_FILESET_ENTRY commands describe constituent Mach-O files that are part
+ * of a fileset. In one implementation, entries are dylibs with individual
+ * mach headers and repositionable text and data segments. Each entry is
+ * further described by its own mach header.
+ */
+struct fileset_entry_command {
+    uint32_t     cmd;        /* LC_FILESET_ENTRY */
+    uint32_t     cmdsize;    /* includes entry_id string */
+    uint64_t     vmaddr;     /* memory address of the entry */
+    uint64_t     fileoff;    /* file offset of the entry */
+    union lc_str entry_id;   /* contained entry id */
+    uint32_t     reserved;   /* reserved */
+};
+
+/*
+ * These deprecated values may still be used within Apple but are mechanically
+ * removed from public API. The mechanical process may produce unusual results.
+ */
+#if (!defined(PLATFORM_MACCATALYST))
+#define PLATFORM_MACCATALYST PLATFORM_MACCATALYST
+#endif
+
 #endif /* _MACHO_LOADER_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/clock.h b/lib/libc/include/any-macos.13-any/mach/clock.h
similarity index 94%
rename from lib/libc/include/x86_64-macos.10-none/mach/clock.h
rename to lib/libc/include/any-macos.13-any/mach/clock.h
index ec293fc9c1..04c8b8ec0b 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/clock.h
+++ b/lib/libc/include/any-macos.13-any/mach/clock.h
@@ -25,7 +25,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
+#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_ATTR
+#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_COUNTEDBY_ATTR(C) __unsafe_indexable
+#endif
+	extern int mig_strncpy_zerofill(char * dest, const char * src, int len) __attribute__((weak_import));
 #ifdef __cplusplus
 }
 #endif
@@ -41,7 +44,7 @@ extern "C" {
 #define FUNCTION_PTR_T
 typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
 typedef struct {
-        char            *name;
+        char            * name;
         function_ptr_t  function;
 } function_table_entry;
 typedef function_table_entry   *function_table_t;
@@ -52,6 +55,7 @@ typedef function_table_entry   *function_table_t;
 #define	clock_MSG_COUNT	3
 #endif	/* clock_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/clock_priv.h b/lib/libc/include/any-macos.13-any/mach/clock_priv.h
similarity index 93%
rename from lib/libc/include/x86_64-macos.10-none/mach/clock_priv.h
rename to lib/libc/include/any-macos.13-any/mach/clock_priv.h
index 0c9d11d9c6..ced1925a05 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/clock_priv.h
+++ b/lib/libc/include/any-macos.13-any/mach/clock_priv.h
@@ -25,7 +25,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
+#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_ATTR
+#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_COUNTEDBY_ATTR(C) __unsafe_indexable
+#endif
+	extern int mig_strncpy_zerofill(char * dest, const char * src, int len) __attribute__((weak_import));
 #ifdef __cplusplus
 }
 #endif
@@ -41,7 +44,7 @@ extern "C" {
 #define FUNCTION_PTR_T
 typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
 typedef struct {
-        char            *name;
+        char            * name;
         function_ptr_t  function;
 } function_table_entry;
 typedef function_table_entry   *function_table_t;
@@ -52,6 +55,7 @@ typedef function_table_entry   *function_table_t;
 #define	clock_priv_MSG_COUNT	2
 #endif	/* clock_priv_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/exception_types.h b/lib/libc/include/any-macos.13-any/mach/exception_types.h
similarity index 92%
rename from lib/libc/include/x86_64-macos.10-none/mach/exception_types.h
rename to lib/libc/include/any-macos.13-any/mach/exception_types.h
index a0026b9ce2..d56a8ac748 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/exception_types.h
+++ b/lib/libc/include/any-macos.13-any/mach/exception_types.h
@@ -102,34 +102,42 @@
 
 #define EXC_CORPSE_NOTIFY       13      /* Abnormal process exited to corpse state */
 
-#define EXC_CORPSE_VARIANT_BIT  0x100  /* bit set for EXC_*_CORPSE variants of EXC_* */
-
 
 /*
  *	Machine-independent exception behaviors
  */
 
-# define EXCEPTION_DEFAULT              1
+#define EXCEPTION_DEFAULT              1
 /*	Send a catch_exception_raise message including the identity.
  */
 
-# define EXCEPTION_STATE                2
+#define EXCEPTION_STATE                2
 /*	Send a catch_exception_raise_state message including the
  *	thread state.
  */
 
-# define EXCEPTION_STATE_IDENTITY       3
+#define EXCEPTION_STATE_IDENTITY       3
 /*	Send a catch_exception_raise_state_identity message including
  *	the thread identity and state.
  */
 
+#define EXCEPTION_IDENTITY_PROTECTED   4
+/*	Send a catch_exception_raise_identity_protected message including protected task
+ *  and thread identity.
+ */
+
+#define MACH_EXCEPTION_BACKTRACE_PREFERRED   0x20000000
+/* Prefer sending a catch_exception_raice_backtrace message, if applicable */
+
 #define MACH_EXCEPTION_ERRORS           0x40000000
 /*	include additional exception specific errors, not used yet.  */
 
 #define MACH_EXCEPTION_CODES            0x80000000
 /*	Send 64-bit code and subcode in the exception header */
 
-#define MACH_EXCEPTION_MASK             (MACH_EXCEPTION_CODES | MACH_EXCEPTION_ERRORS)
+#define MACH_EXCEPTION_MASK             (MACH_EXCEPTION_CODES | \
+	                                    MACH_EXCEPTION_ERRORS | \
+	                                    MACH_EXCEPTION_BACKTRACE_PREFERRED)
 /*
  * Masks for exception definitions, above
  * bit zero is unused, therefore 1 word = 31 exception types
@@ -181,6 +189,7 @@
 #include <mach/port.h>
 #include <mach/thread_status.h>
 #include <mach/machine/vm_types.h>
+#include <mach_debug/ipc_info.h>
 /*
  * Exported types
  */
@@ -196,6 +205,7 @@ typedef exception_mask_t                *exception_mask_array_t;
 typedef exception_behavior_t            *exception_behavior_array_t;
 typedef thread_state_flavor_t           *exception_flavor_array_t;
 typedef mach_port_t                     *exception_port_array_t;
+typedef ipc_info_port_t                 *exception_port_info_array_t;
 typedef mach_exception_data_type_t      mach_exception_code_t;
 typedef mach_exception_data_type_t      mach_exception_subcode_t;
 
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/host_priv.h b/lib/libc/include/any-macos.13-any/mach/host_priv.h
similarity index 98%
rename from lib/libc/include/x86_64-macos.10-none/mach/host_priv.h
rename to lib/libc/include/any-macos.13-any/mach/host_priv.h
index 9445ae5d93..79d27d1f67 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/host_priv.h
+++ b/lib/libc/include/any-macos.13-any/mach/host_priv.h
@@ -25,7 +25,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
+#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_ATTR
+#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_COUNTEDBY_ATTR(C) __unsafe_indexable
+#endif
+	extern int mig_strncpy_zerofill(char * dest, const char * src, int len) __attribute__((weak_import));
 #ifdef __cplusplus
 }
 #endif
@@ -41,7 +44,7 @@ extern "C" {
 #define FUNCTION_PTR_T
 typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
 typedef struct {
-        char            *name;
+        char            * name;
         function_ptr_t  function;
 } function_table_entry;
 typedef function_table_entry   *function_table_t;
@@ -52,6 +55,7 @@ typedef function_table_entry   *function_table_t;
 #define	host_priv_MSG_COUNT	26
 #endif	/* host_priv_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/host_security.h b/lib/libc/include/any-macos.13-any/mach/host_security.h
similarity index 94%
rename from lib/libc/include/x86_64-macos.10-none/mach/host_security.h
rename to lib/libc/include/any-macos.13-any/mach/host_security.h
index 1c1b6d9144..4f7e86ad30 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/host_security.h
+++ b/lib/libc/include/any-macos.13-any/mach/host_security.h
@@ -25,7 +25,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
+#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_ATTR
+#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_COUNTEDBY_ATTR(C) __unsafe_indexable
+#endif
+	extern int mig_strncpy_zerofill(char * dest, const char * src, int len) __attribute__((weak_import));
 #ifdef __cplusplus
 }
 #endif
@@ -41,7 +44,7 @@ extern "C" {
 #define FUNCTION_PTR_T
 typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
 typedef struct {
-        char            *name;
+        char            * name;
         function_ptr_t  function;
 } function_table_entry;
 typedef function_table_entry   *function_table_t;
@@ -52,6 +55,7 @@ typedef function_table_entry   *function_table_t;
 #define	host_security_MSG_COUNT	2
 #endif	/* host_security_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/host_special_ports.h b/lib/libc/include/any-macos.13-any/mach/host_special_ports.h
similarity index 91%
rename from lib/libc/include/x86_64-macos.10-none/mach/host_special_ports.h
rename to lib/libc/include/any-macos.13-any/mach/host_special_ports.h
index 8d4cdbefce..6b73217bbe 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/host_special_ports.h
+++ b/lib/libc/include/any-macos.13-any/mach/host_special_ports.h
@@ -76,10 +76,10 @@
  */
 #define HOST_PORT                        1
 #define HOST_PRIV_PORT                   2
-#define HOST_IO_MASTER_PORT              3
+#define HOST_IO_MAIN_PORT                3
 #define HOST_MAX_SPECIAL_KERNEL_PORT     7 /* room to grow */
 
-#define HOST_LAST_SPECIAL_KERNEL_PORT    HOST_IO_MASTER_PORT
+#define HOST_LAST_SPECIAL_KERNEL_PORT    HOST_IO_MAIN_PORT
 
 /*
  * Not provided by kernel
@@ -108,9 +108,11 @@
 #define HOST_SYSPOLICYD_PORT            (22 + HOST_MAX_SPECIAL_KERNEL_PORT)
 #define HOST_FILECOORDINATIOND_PORT     (23 + HOST_MAX_SPECIAL_KERNEL_PORT)
 #define HOST_FAIRPLAYD_PORT             (24 + HOST_MAX_SPECIAL_KERNEL_PORT)
+#define HOST_IOCOMPRESSIONSTATS_PORT    (25 + HOST_MAX_SPECIAL_KERNEL_PORT)
+#define HOST_MEMORY_ERROR_PORT          (26 + HOST_MAX_SPECIAL_KERNEL_PORT)
 
-#define HOST_MAX_SPECIAL_PORT           HOST_FAIRPLAYD_PORT
-/* MAX = last since rdar://35861175 */
+#define HOST_MAX_SPECIAL_PORT           HOST_MEMORY_ERROR_PORT
+/* MAX = last since rdar://59872249 */
 
 /* obsolete name */
 #define HOST_CHUD_PORT HOST_LAUNCHCTL_PORT
@@ -137,10 +139,10 @@
 	HOST_LOCAL_NODE, HOST_PRIV_PORT, (port)))
 #define host_set_host_priv_port(host, port) (KERN_INVALID_ARGUMENT)
 
-#define host_get_io_master_port(host, port)     \
+#define host_get_io_main_port(host, port)     \
 	(host_get_special_port((host),          \
-	HOST_LOCAL_NODE, HOST_IO_MASTER_PORT, (port)))
-#define host_set_io_master_port(host, port) (KERN_INVALID_ARGUMENT)
+	HOST_LOCAL_NODE, HOST_IO_MAIN_PORT, (port)))
+#define host_set_io_main_port(host, port) (KERN_INVALID_ARGUMENT)
 
 /*
  * User-settable special ports.
@@ -274,6 +276,18 @@
 #define host_set_fairplayd_port(host, port)     \
 	(host_set_special_port((host), HOST_FAIRPLAYD_PORT, (port)))
 
+#define host_get_iocompressionstats_port(host, port)     \
+	(host_get_special_port((host),                  \
+	HOST_LOCAL_NODE, HOST_IOCOMPRESSIONSTATS_PORT, (port)))
+#define host_set_iocompressionstats_port(host, port)     \
+	(host_set_special_port((host), HOST_IOCOMPRESSIONSTATS_PORT, (port)))
+
+#define host_get_memory_error_port(host, port)     \
+	(host_get_special_port((host),                  \
+	HOST_LOCAL_NODE, HOST_MEMORY_ERROR_PORT, (port)))
+#define host_set_memory_error_port(host, port)     \
+	(host_set_special_port((host), HOST_MEMORY_ERROR_PORT, (port)))
+
 /* HOST_RESOURCE_NOTIFY_PORT doesn't #defines these conveniences.
  *  All lookups go through send_resource_violation()
  */
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/mach.h b/lib/libc/include/any-macos.13-any/mach/mach.h
similarity index 99%
rename from lib/libc/include/x86_64-macos.10-none/mach/mach.h
rename to lib/libc/include/any-macos.13-any/mach/mach.h
index 159fd67b99..712d4e1cab 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/mach.h
+++ b/lib/libc/include/any-macos.13-any/mach/mach.h
@@ -85,10 +85,6 @@ __BEGIN_DECLS
 extern void                     panic_init(mach_port_t);
 extern void                     panic(const char *, ...);
 
-extern void                     safe_gets(char *,
-    char *,
-    int);
-
 extern void                     slot_name(cpu_type_t,
     cpu_subtype_t,
     char **,
@@ -237,9 +233,9 @@ extern voucher_mach_msg_state_t voucher_mach_msg_adopt(mach_msg_header_t *msg);
  * @param state
  * The thread voucher state to restore.
  */
-
 extern void voucher_mach_msg_revert(voucher_mach_msg_state_t state);
 
+
 __END_DECLS
 
 #endif  /* _MACH_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/mach_host.h b/lib/libc/include/any-macos.13-any/mach/mach_host.h
similarity index 97%
rename from lib/libc/include/x86_64-macos.10-none/mach/mach_host.h
rename to lib/libc/include/any-macos.13-any/mach/mach_host.h
index a5b6d2cd84..2cdf4c33a9 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/mach_host.h
+++ b/lib/libc/include/any-macos.13-any/mach/mach_host.h
@@ -25,7 +25,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
+#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_ATTR
+#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_COUNTEDBY_ATTR(C) __unsafe_indexable
+#endif
+	extern int mig_strncpy_zerofill(char * dest, const char * src, int len) __attribute__((weak_import));
 #ifdef __cplusplus
 }
 #endif
@@ -41,7 +44,7 @@ extern "C" {
 #define FUNCTION_PTR_T
 typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
 typedef struct {
-        char            *name;
+        char            * name;
         function_ptr_t  function;
 } function_table_entry;
 typedef function_table_entry   *function_table_t;
@@ -52,6 +55,7 @@ typedef function_table_entry   *function_table_t;
 #define	mach_host_MSG_COUNT	35
 #endif	/* mach_host_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>
@@ -74,8 +78,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t host_info
 (
 	host_t host,
@@ -139,16 +142,16 @@ kern_return_t host_processor_info
 	mach_msg_type_number_t *out_processor_infoCnt
 );
 
-/* Routine host_get_io_master */
+/* Routine host_get_io_main */
 #ifdef	mig_external
 mig_external
 #else
 extern
 #endif	/* mig_external */
-kern_return_t host_get_io_master
+kern_return_t host_get_io_main
 (
 	host_t host,
-	io_master_t *io_master
+	io_main_t *io_main
 );
 
 /* Routine host_get_clock_service */
@@ -251,8 +254,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t host_request_notification
 (
 	host_t host,
@@ -308,8 +310,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t host_create_mach_voucher
 (
 	host_t host,
@@ -324,8 +325,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t host_register_mach_voucher_attr_manager
 (
 	host_t host,
@@ -341,8 +341,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t host_register_well_known_mach_voucher_attr_manager
 (
 	host_t host,
@@ -358,8 +357,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t host_set_atm_diagnostic_flag
 (
 	host_t host,
@@ -372,8 +370,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t host_get_atm_diagnostic_flag
 (
 	host_t host,
@@ -532,7 +529,7 @@ __END_DECLS
 #endif
 	typedef struct {
 		mach_msg_header_t Head;
-	} __Request__host_get_io_master_t __attribute__((unused));
+	} __Request__host_get_io_main_t __attribute__((unused));
 #ifdef  __MigPackStructs
 #pragma pack(pop)
 #endif
@@ -802,7 +799,7 @@ union __RequestUnion__mach_host_subsystem {
 	__Request___host_page_size_t Request__host_page_size;
 	__Request__mach_memory_object_memory_entry_t Request_mach_memory_object_memory_entry;
 	__Request__host_processor_info_t Request_host_processor_info;
-	__Request__host_get_io_master_t Request_host_get_io_master;
+	__Request__host_get_io_main_t Request_host_get_io_main;
 	__Request__host_get_clock_service_t Request_host_get_clock_service;
 	__Request__kmod_get_info_t Request_kmod_get_info;
 	__Request__host_virtual_physical_table_info_t Request_host_virtual_physical_table_info;
@@ -911,9 +908,9 @@ union __RequestUnion__mach_host_subsystem {
 		mach_msg_header_t Head;
 		/* start of the kernel processed data */
 		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t io_master;
+		mach_msg_port_descriptor_t io_main;
 		/* end of the kernel processed data */
-	} __Reply__host_get_io_master_t __attribute__((unused));
+	} __Reply__host_get_io_main_t __attribute__((unused));
 #ifdef  __MigPackStructs
 #pragma pack(pop)
 #endif
@@ -1232,7 +1229,7 @@ union __ReplyUnion__mach_host_subsystem {
 	__Reply___host_page_size_t Reply__host_page_size;
 	__Reply__mach_memory_object_memory_entry_t Reply_mach_memory_object_memory_entry;
 	__Reply__host_processor_info_t Reply_host_processor_info;
-	__Reply__host_get_io_master_t Reply_host_get_io_master;
+	__Reply__host_get_io_main_t Reply_host_get_io_main;
 	__Reply__host_get_clock_service_t Reply_host_get_clock_service;
 	__Reply__kmod_get_info_t Reply_kmod_get_info;
 	__Reply__host_virtual_physical_table_info_t Reply_host_virtual_physical_table_info;
@@ -1264,7 +1261,7 @@ union __ReplyUnion__mach_host_subsystem {
     { "_host_page_size", 202 },\
     { "mach_memory_object_memory_entry", 203 },\
     { "host_processor_info", 204 },\
-    { "host_get_io_master", 205 },\
+    { "host_get_io_main", 205 },\
     { "host_get_clock_service", 206 },\
     { "kmod_get_info", 207 },\
     { "host_virtual_physical_table_info", 209 },\
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/sync_policy.h b/lib/libc/include/any-macos.13-any/mach/mach_interface.h
similarity index 63%
rename from lib/libc/include/x86_64-macos.10-none/mach/sync_policy.h
rename to lib/libc/include/any-macos.13-any/mach/mach_interface.h
index a4c477bf5d..3006004f44 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/sync_policy.h
+++ b/lib/libc/include/any-macos.13-any/mach/mach_interface.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -26,24 +26,27 @@
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 /*
- * @OSF_COPYRIGHT@
+ * Copyright (C) Apple Computer 1998
+ * ALL Rights Reserved
  */
-
-#ifndef _MACH_SYNC_POLICY_H_
-#define _MACH_SYNC_POLICY_H_
-
-typedef int sync_policy_t;
-
 /*
- *	These options define the wait ordering of the synchronizers
+ * This file represents the interfaces that used to come
+ * from creating the user headers from the mach.defs file.
+ * Because mach.defs was decomposed, this file now just
+ * wraps up all the new interface headers generated from
+ * each of the new .defs resulting from that decomposition.
  */
-#define SYNC_POLICY_FIFO                0x0
-#define SYNC_POLICY_FIXED_PRIORITY      0x1
-#define SYNC_POLICY_REVERSED            0x2
-#define SYNC_POLICY_ORDER_MASK          0x3
-#define SYNC_POLICY_LIFO                (SYNC_POLICY_FIFO|SYNC_POLICY_REVERSED)
+#ifndef _MACH_INTERFACE_H_
+#define _MACH_INTERFACE_H_
 
+#include <mach/clock_priv.h>
+#include <mach/host_priv.h>
+#include <mach/host_security.h>
+#include <mach/processor.h>
+#include <mach/processor_set.h>
+#include <mach/semaphore.h>
+#include <mach/task.h>
+#include <mach/thread_act.h>
+#include <mach/vm_map.h>
 
-#define SYNC_POLICY_MAX                 0x7
-
-#endif  /* _MACH_SYNC_POLICY_H_ */
\ No newline at end of file
+#endif /* _MACH_INTERFACE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/mach_port.h b/lib/libc/include/any-macos.13-any/mach/mach_port.h
similarity index 91%
rename from lib/libc/include/x86_64-macos.10-none/mach/mach_port.h
rename to lib/libc/include/any-macos.13-any/mach/mach_port.h
index fcec114ccf..4220fad6b9 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/mach_port.h
+++ b/lib/libc/include/any-macos.13-any/mach/mach_port.h
@@ -25,7 +25,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
+#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_ATTR
+#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_COUNTEDBY_ATTR(C) __unsafe_indexable
+#endif
+	extern int mig_strncpy_zerofill(char * dest, const char * src, int len) __attribute__((weak_import));
 #ifdef __cplusplus
 }
 #endif
@@ -41,7 +44,7 @@ extern "C" {
 #define FUNCTION_PTR_T
 typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
 typedef struct {
-        char            *name;
+        char            * name;
         function_ptr_t  function;
 } function_table_entry;
 typedef function_table_entry   *function_table_t;
@@ -49,9 +52,10 @@ typedef function_table_entry   *function_table_t;
 #endif /* AUTOTEST */
 
 #ifndef	mach_port_MSG_COUNT
-#define	mach_port_MSG_COUNT	40
+#define	mach_port_MSG_COUNT	43
 #endif	/* mach_port_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>
@@ -113,8 +117,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t mach_port_allocate_name
 (
 	ipc_space_t task,
@@ -141,6 +144,9 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
+__API_DEPRECATED("Inherently unsafe API: instead manage rights with "
+    "mach_port_destruct(), mach_port_deallocate() or mach_port_mod_refs()",
+    macos(10.0, 12.0), ios(2.0, 15.0), tvos(9.0, 15.0), watchos(2.0, 8.0))
 kern_return_t mach_port_destroy
 (
 	ipc_space_t task,
@@ -226,7 +232,7 @@ extern
 #endif	/* mig_external */
 kern_return_t mach_port_get_set_status
 (
-	ipc_space_inspect_t task,
+	ipc_space_read_t task,
 	mach_port_name_t name,
 	mach_port_name_array_t *members,
 	mach_msg_type_number_t *membersCnt
@@ -312,7 +318,7 @@ extern
 #endif	/* mig_external */
 kern_return_t mach_port_get_attributes
 (
-	ipc_space_inspect_t task,
+	ipc_space_read_t task,
 	mach_port_name_t name,
 	mach_port_flavor_t flavor,
 	mach_port_info_t port_info_out,
@@ -369,8 +375,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_set_port_space
 (
 	ipc_space_t task,
@@ -398,7 +403,7 @@ extern
 #endif	/* mig_external */
 kern_return_t mach_port_space_info
 (
-	ipc_space_inspect_t task,
+	ipc_space_read_t space,
 	ipc_info_space_t *space_info,
 	ipc_info_name_array_t *table_info,
 	mach_msg_type_number_t *table_infoCnt,
@@ -428,7 +433,7 @@ extern
 #endif	/* mig_external */
 kern_return_t mach_port_kernel_object
 (
-	ipc_space_inspect_t task,
+	ipc_space_read_t task,
 	mach_port_name_t name,
 	unsigned *object_type,
 	unsigned *object_addr
@@ -468,7 +473,7 @@ extern
 #endif	/* mig_external */
 kern_return_t mach_port_get_context
 (
-	ipc_space_inspect_t task,
+	ipc_space_read_t task,
 	mach_port_name_t name,
 	mach_port_context_t *context
 );
@@ -494,7 +499,7 @@ extern
 #endif	/* mig_external */
 kern_return_t mach_port_kobject
 (
-	ipc_space_inspect_t task,
+	ipc_space_read_t task,
 	mach_port_name_t name,
 	natural_t *object_type,
 	mach_vm_address_t *object_addr
@@ -603,13 +608,55 @@ extern
 #endif	/* mig_external */
 kern_return_t mach_port_kobject_description
 (
-	ipc_space_inspect_t task,
+	ipc_space_read_t task,
 	mach_port_name_t name,
 	natural_t *object_type,
 	mach_vm_address_t *object_addr,
 	kobject_description_t description
 );
 
+/* Routine mach_port_is_connection_for_service */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t mach_port_is_connection_for_service
+(
+	ipc_space_t task,
+	mach_port_name_t connection_port,
+	mach_port_name_t service_port,
+	uint64_t *filter_policy_id
+);
+
+/* Routine mach_port_get_service_port_info */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t mach_port_get_service_port_info
+(
+	ipc_space_read_t task,
+	mach_port_name_t name,
+	mach_service_port_info_data_t *sp_info_out
+);
+
+/* Routine mach_port_assert_attributes */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t mach_port_assert_attributes
+(
+	ipc_space_t task,
+	mach_port_name_t name,
+	mach_port_flavor_t flavor,
+	mach_port_info_t info,
+	mach_msg_type_number_t infoCnt
+);
+
 __END_DECLS
 
 /********************** Caution **************************/
@@ -1139,6 +1186,46 @@ __END_DECLS
 #ifdef  __MigPackStructs
 #pragma pack(pop)
 #endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		mach_port_name_t connection_port;
+		mach_port_name_t service_port;
+	} __Request__mach_port_is_connection_for_service_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		mach_port_name_t name;
+	} __Request__mach_port_get_service_port_info_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		mach_port_name_t name;
+		mach_port_flavor_t flavor;
+		mach_msg_type_number_t infoCnt;
+		integer_t info[17];
+	} __Request__mach_port_assert_attributes_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
 #endif /* !__Request__mach_port_subsystem__defined */
 
 /* union of all requests */
@@ -1185,6 +1272,9 @@ union __RequestUnion__mach_port_subsystem {
 	__Request__mach_port_guard_with_flags_t Request_mach_port_guard_with_flags;
 	__Request__mach_port_swap_guard_t Request_mach_port_swap_guard;
 	__Request__mach_port_kobject_description_t Request_mach_port_kobject_description;
+	__Request__mach_port_is_connection_for_service_t Request_mach_port_is_connection_for_service;
+	__Request__mach_port_get_service_port_info_t Request_mach_port_get_service_port_info;
+	__Request__mach_port_assert_attributes_t Request_mach_port_assert_attributes;
 };
 #endif /* !__RequestUnion__mach_port_subsystem__defined */
 /* typedefs for all replies */
@@ -1709,6 +1799,44 @@ union __RequestUnion__mach_port_subsystem {
 #ifdef  __MigPackStructs
 #pragma pack(pop)
 #endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		uint64_t filter_policy_id;
+	} __Reply__mach_port_is_connection_for_service_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		mach_service_port_info_data_t sp_info_out;
+	} __Reply__mach_port_get_service_port_info_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+	} __Reply__mach_port_assert_attributes_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
 #endif /* !__Reply__mach_port_subsystem__defined */
 
 /* union of all replies */
@@ -1755,6 +1883,9 @@ union __ReplyUnion__mach_port_subsystem {
 	__Reply__mach_port_guard_with_flags_t Reply_mach_port_guard_with_flags;
 	__Reply__mach_port_swap_guard_t Reply_mach_port_swap_guard;
 	__Reply__mach_port_kobject_description_t Reply_mach_port_kobject_description;
+	__Reply__mach_port_is_connection_for_service_t Reply_mach_port_is_connection_for_service;
+	__Reply__mach_port_get_service_port_info_t Reply_mach_port_get_service_port_info;
+	__Reply__mach_port_assert_attributes_t Reply_mach_port_assert_attributes;
 };
 #endif /* !__RequestUnion__mach_port_subsystem__defined */
 
@@ -1798,7 +1929,10 @@ union __ReplyUnion__mach_port_subsystem {
     { "mach_port_space_basic_info", 3235 },\
     { "mach_port_guard_with_flags", 3237 },\
     { "mach_port_swap_guard", 3238 },\
-    { "mach_port_kobject_description", 3239 }
+    { "mach_port_kobject_description", 3239 },\
+    { "mach_port_is_connection_for_service", 3240 },\
+    { "mach_port_get_service_port_info", 3241 },\
+    { "mach_port_assert_attributes", 3242 }
 #endif
 
 #ifdef __AfterMigUserHeader
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/mach_types.h b/lib/libc/include/any-macos.13-any/mach/mach_types.h
similarity index 82%
rename from lib/libc/include/x86_64-macos.10-none/mach/mach_types.h
rename to lib/libc/include/any-macos.13-any/mach/mach_types.h
index 0c35705acf..ed1885d120 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/mach_types.h
+++ b/lib/libc/include/any-macos.13-any/mach/mach_types.h
@@ -117,12 +117,17 @@
  */
 typedef mach_port_t             task_t;
 typedef mach_port_t             task_name_t;
+typedef mach_port_t             task_policy_set_t;
+typedef mach_port_t             task_policy_get_t;
 typedef mach_port_t             task_inspect_t;
+typedef mach_port_t             task_read_t;
 typedef mach_port_t             task_suspension_token_t;
 typedef mach_port_t             thread_t;
 typedef mach_port_t             thread_act_t;
 typedef mach_port_t             thread_inspect_t;
+typedef mach_port_t             thread_read_t;
 typedef mach_port_t             ipc_space_t;
+typedef mach_port_t             ipc_space_read_t;
 typedef mach_port_t             ipc_space_inspect_t;
 typedef mach_port_t             coalition_t;
 typedef mach_port_t             host_t;
@@ -138,7 +143,10 @@ typedef mach_port_t             alarm_t;
 typedef mach_port_t             clock_serv_t;
 typedef mach_port_t             clock_ctrl_t;
 typedef mach_port_t             arcade_register_t;
-typedef mach_port_t             suid_cred_t;
+typedef mach_port_t             ipc_eventlink_t;
+typedef mach_port_t             eventlink_port_pair_t[2];
+typedef mach_port_t             task_id_token_t;
+typedef mach_port_t             kcdata_object_t;
 
 
 /*
@@ -157,8 +165,11 @@ typedef mach_port_t             mem_entry_name_port_t;
 typedef mach_port_t             exception_handler_t;
 typedef exception_handler_t     *exception_handler_array_t;
 typedef mach_port_t             vm_task_entry_t;
-typedef mach_port_t             io_master_t;
+typedef mach_port_t             io_main_t;
 typedef mach_port_t             UNDServerRef;
+typedef mach_port_t             mach_eventlink_t;
+
+typedef ipc_info_port_t         exception_handler_info_t;
 
 /*
  * Mig doesn't translate the components of an array.
@@ -207,17 +218,19 @@ typedef exception_handler_t     exception_port_t;
 typedef exception_handler_array_t exception_port_arrary_t;
 typedef char vfs_path_t[4096];
 typedef char nspace_path_t[1024]; /* 1024 == PATH_MAX */
-typedef char suid_cred_path_t[1024];
-typedef uint32_t suid_cred_uid_t;
+typedef char nspace_name_t[1024]; /* 1024 == PATH_MAX */
 
 #define TASK_NULL               ((task_t) 0)
 #define TASK_NAME_NULL          ((task_name_t) 0)
-#define TASK_INSPECT_NULL               ((task_inspect_t) 0)
+#define TASK_INSPECT_NULL       ((task_inspect_t) 0)
+#define TASK_READ_NULL          ((task_read_t) 0)
 #define THREAD_NULL             ((thread_t) 0)
 #define THREAD_INSPECT_NULL     ((thread_inspect_t) 0)
+#define THREAD_READ_NULL        ((thread_read_t) 0)
 #define TID_NULL                ((uint64_t) 0)
 #define THR_ACT_NULL            ((thread_act_t) 0)
 #define IPC_SPACE_NULL          ((ipc_space_t) 0)
+#define IPC_SPACE_READ_NULL     ((ipc_space_read_t) 0)
 #define IPC_SPACE_INSPECT_NULL  ((ipc_space_inspect_t) 0)
 #define COALITION_NULL          ((coalition_t) 0)
 #define HOST_NULL               ((host_t) 0)
@@ -232,10 +245,33 @@ typedef uint32_t suid_cred_uid_t;
 #define CLOCK_NULL              ((clock_t) 0)
 #define UND_SERVER_NULL         ((UNDServerRef) 0)
 #define ARCADE_REG_NULL         ((arcade_register_t) 0)
-#define SUID_CRED_NULL         ((suid_cred_t) 0)
+#define MACH_EVENTLINK_NULL     ((mach_eventlink_t) 0)
+#define IPC_EVENTLINK_NULL      ((ipc_eventlink_t) 0)
+#define TASK_ID_TOKEN_NULL      ((task_id_token_t) 0)
+#define KCDATA_OBJECT_NULL      ((kcdata_object_t) 0)
+
+/* capability strictly _DECREASING_.
+ * not ordered the other way around because we want TASK_FLAVOR_CONTROL
+ * to be closest to the itk_lock. see task.h.
+ */
+typedef unsigned int            mach_task_flavor_t;
+#define TASK_FLAVOR_CONTROL     0    /* a task_t */
+#define TASK_FLAVOR_READ        1    /* a task_read_t */
+#define TASK_FLAVOR_INSPECT     2    /* a task_inspect_t */
+#define TASK_FLAVOR_NAME        3    /* a task_name_t */
+
+#define TASK_FLAVOR_MAX         TASK_FLAVOR_NAME
+
+/* capability strictly _DECREASING_ */
+typedef unsigned int            mach_thread_flavor_t;
+#define THREAD_FLAVOR_CONTROL   0    /* a thread_t */
+#define THREAD_FLAVOR_READ      1    /* a thread_read_t */
+#define THREAD_FLAVOR_INSPECT   2    /* a thread_inspect_t */
+
+#define THREAD_FLAVOR_MAX       THREAD_FLAVOR_INSPECT
 
 /* DEPRECATED */
-typedef natural_t       ledger_item_t;
+typedef natural_t               ledger_item_t;
 #define LEDGER_ITEM_INFINITY    ((ledger_item_t) (~0))
 
 typedef int64_t                 ledger_amount_t;
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/mach_voucher_types.h b/lib/libc/include/any-macos.13-any/mach/mach_voucher_types.h
similarity index 97%
rename from lib/libc/include/x86_64-macos.10-none/mach/mach_voucher_types.h
rename to lib/libc/include/any-macos.13-any/mach/mach_voucher_types.h
index b5b34d7e4c..5a54f93633 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/mach_voucher_types.h
+++ b/lib/libc/include/any-macos.13-any/mach/mach_voucher_types.h
@@ -31,6 +31,7 @@
 
 #include <mach/std_types.h>
 #include <mach/port.h>
+#include <mach/message.h>
 
 /*
  * Mach Voucher - an immutable collection of attribute value handles.
@@ -91,12 +92,14 @@ typedef mach_voucher_attr_key_t *mach_voucher_attr_key_array_t;
 #define MACH_VOUCHER_ATTR_KEY_ATM               ((mach_voucher_attr_key_t)1)
 #define MACH_VOUCHER_ATTR_KEY_IMPORTANCE        ((mach_voucher_attr_key_t)2)
 #define MACH_VOUCHER_ATTR_KEY_BANK              ((mach_voucher_attr_key_t)3)
-#define MACH_VOUCHER_ATTR_KEY_PTHPRIORITY       ((mach_voucher_attr_key_t)4)
 
+/* following keys have been removed from embedded platforms */
+#define MACH_VOUCHER_ATTR_KEY_PTHPRIORITY       ((mach_voucher_attr_key_t)4)
 #define MACH_VOUCHER_ATTR_KEY_USER_DATA         ((mach_voucher_attr_key_t)7)
-#define MACH_VOUCHER_ATTR_KEY_BITS              MACH_VOUCHER_ATTR_KEY_USER_DATA /* deprecated */
+#define MACH_VOUCHER_ATTR_KEY_BITS              MACH_VOUCHER_ATTR_KEY_USER_DATA
 #define MACH_VOUCHER_ATTR_KEY_TEST              ((mach_voucher_attr_key_t)8)
 
+/* not used, for compatibility only */
 #define MACH_VOUCHER_ATTR_KEY_NUM_WELL_KNOWN    MACH_VOUCHER_ATTR_KEY_TEST
 
 /*
@@ -212,7 +215,7 @@ typedef mach_port_t             ipc_voucher_attr_control_t;
  * The private handle that the voucher attribute manager provides to
  * the mach voucher mechanism to represent a given attr content/value.
  */
-typedef uint64_t mach_voucher_attr_value_handle_t;
+typedef uint64_t mach_voucher_attr_value_handle_t __kernel_ptr_semantics;
 typedef mach_voucher_attr_value_handle_t *mach_voucher_attr_value_handle_array_t;
 
 typedef mach_msg_type_number_t mach_voucher_attr_value_handle_array_size_t;
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/machine.h b/lib/libc/include/any-macos.13-any/mach/machine.h
similarity index 94%
rename from lib/libc/include/x86_64-macos.10-none/mach/machine.h
rename to lib/libc/include/any-macos.13-any/mach/machine.h
index 30aafcc812..21f1b3892e 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/machine.h
+++ b/lib/libc/include/any-macos.13-any/mach/machine.h
@@ -118,6 +118,10 @@ typedef integer_t       cpu_threadtype_t;
 #define CPU_TYPE_POWERPC                ((cpu_type_t) 18)
 #define CPU_TYPE_POWERPC64              (CPU_TYPE_POWERPC | CPU_ARCH_ABI64)
 /* skip				((cpu_type_t) 19)	*/
+/* skip				((cpu_type_t) 20 */
+/* skip				((cpu_type_t) 21 */
+/* skip				((cpu_type_t) 22 */
+/* skip				((cpu_type_t) 23 */
 
 /*
  *	Machine subtypes (these are defined here, instead of in a machine
@@ -130,7 +134,14 @@ typedef integer_t       cpu_threadtype_t;
  */
 #define CPU_SUBTYPE_MASK        0xff000000      /* mask for feature flags */
 #define CPU_SUBTYPE_LIB64       0x80000000      /* 64 bit libraries */
+#define CPU_SUBTYPE_PTRAUTH_ABI 0x80000000      /* pointer authentication with versioned ABI */
 
+/*
+ *      When selecting a slice, ANY will pick the slice with the best
+ *      grading for the selected cpu_type_t, unlike the "ALL" subtypes,
+ *      which are the slices that can run on any hardware for that cpu type.
+ */
+#define CPU_SUBTYPE_ANY         ((cpu_subtype_t) -1)
 
 /*
  *	Object files that are hand-crafted to run on any
@@ -365,12 +376,8 @@ typedef integer_t       cpu_threadtype_t;
 #define CPUFAMILY_INTEL_BROADWELL       0x582ed09c
 #define CPUFAMILY_INTEL_SKYLAKE         0x37fc219f
 #define CPUFAMILY_INTEL_KABYLAKE        0x0f817246
-#if !defined(RC_HIDE_XNU_ICELAKE)
 #define CPUFAMILY_INTEL_ICELAKE         0x38435547
-#endif /* not RC_HIDE_XNU_ICELAKE */
-#if !defined(RC_HIDE_XNU_COMETLAKE)
 #define CPUFAMILY_INTEL_COMETLAKE       0x1cf8a03e
-#endif /* not RC_HIDE_XNU_COMETLAKE */
 #define CPUFAMILY_ARM_9                 0xe73283ae
 #define CPUFAMILY_ARM_11                0x8ff620d8
 #define CPUFAMILY_ARM_XSCALE            0x53b005f5
@@ -386,6 +393,17 @@ typedef integer_t       cpu_threadtype_t;
 #define CPUFAMILY_ARM_MONSOON_MISTRAL   0xe81e7ef6
 #define CPUFAMILY_ARM_VORTEX_TEMPEST    0x07d34b9f
 #define CPUFAMILY_ARM_LIGHTNING_THUNDER 0x462504d2
+#define CPUFAMILY_ARM_FIRESTORM_ICESTORM 0x1b588bb3
+#define CPUFAMILY_ARM_BLIZZARD_AVALANCHE 0xda33d83d
+#define CPUFAMILY_ARM_EVEREST_SAWTOOTH  0x8765edea
+
+/* Described in rdar://64125549 */
+#define CPUSUBFAMILY_UNKNOWN            0
+#define CPUSUBFAMILY_ARM_HP             1
+#define CPUSUBFAMILY_ARM_HG             2
+#define CPUSUBFAMILY_ARM_M              3
+#define CPUSUBFAMILY_ARM_HS             4
+#define CPUSUBFAMILY_ARM_HC_HD          5
 
 /* The following synonyms are deprecated: */
 #define CPUFAMILY_INTEL_6_23    CPUFAMILY_INTEL_PENRYN
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/message.h b/lib/libc/include/any-macos.13-any/mach/message.h
similarity index 94%
rename from lib/libc/include/x86_64-macos.10-none/mach/message.h
rename to lib/libc/include/any-macos.13-any/mach/message.h
index 3f9f9a0605..a6e6e2e043 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/message.h
+++ b/lib/libc/include/any-macos.13-any/mach/message.h
@@ -228,6 +228,7 @@ typedef unsigned int mach_msg_priority_t;
 
 #define MACH_MSG_PRIORITY_UNSPECIFIED (mach_msg_priority_t) 0
 
+
 typedef unsigned int mach_msg_type_name_t;
 
 #define MACH_MSG_TYPE_MOVE_RECEIVE      16      /* Must hold receive right */
@@ -277,16 +278,18 @@ typedef unsigned int mach_msg_descriptor_type_t;
 #define MACH_MSG_OOL_VOLATILE_DESCRIPTOR        3
 #define MACH_MSG_GUARDED_PORT_DESCRIPTOR        4
 
+#define MACH_MSG_DESCRIPTOR_MAX MACH_MSG_GUARDED_PORT_DESCRIPTOR
+
 #pragma pack(push, 4)
 
-typedef struct{
+typedef struct {
 	natural_t                     pad1;
 	mach_msg_size_t               pad2;
 	unsigned int                  pad3 : 24;
 	mach_msg_descriptor_type_t    type : 8;
 } mach_msg_type_descriptor_t;
 
-typedef struct{
+typedef struct {
 	mach_port_t                   name;
 // Pad to 8 bytes everywhere except the K64 kernel where mach_port_t is 8 bytes
 	mach_msg_size_t               pad1;
@@ -295,7 +298,8 @@ typedef struct{
 	mach_msg_descriptor_type_t    type : 8;
 } mach_msg_port_descriptor_t;
 
-typedef struct{
+
+typedef struct {
 	uint32_t                      address;
 	mach_msg_size_t               size;
 	boolean_t                     deallocate: 8;
@@ -304,7 +308,7 @@ typedef struct{
 	mach_msg_descriptor_type_t    type: 8;
 } mach_msg_ool_descriptor32_t;
 
-typedef struct{
+typedef struct {
 	uint64_t                      address;
 	boolean_t                     deallocate: 8;
 	mach_msg_copy_options_t       copy: 8;
@@ -313,7 +317,7 @@ typedef struct{
 	mach_msg_size_t               size;
 } mach_msg_ool_descriptor64_t;
 
-typedef struct{
+typedef struct {
 	void*                         address;
 #if !defined(__LP64__)
 	mach_msg_size_t               size;
@@ -327,7 +331,7 @@ typedef struct{
 #endif
 } mach_msg_ool_descriptor_t;
 
-typedef struct{
+typedef struct {
 	uint32_t                      address;
 	mach_msg_size_t               count;
 	boolean_t                     deallocate: 8;
@@ -336,7 +340,7 @@ typedef struct{
 	mach_msg_descriptor_type_t    type : 8;
 } mach_msg_ool_ports_descriptor32_t;
 
-typedef struct{
+typedef struct {
 	uint64_t                      address;
 	boolean_t                     deallocate: 8;
 	mach_msg_copy_options_t       copy: 8;
@@ -345,7 +349,7 @@ typedef struct{
 	mach_msg_size_t               count;
 } mach_msg_ool_ports_descriptor64_t;
 
-typedef struct{
+typedef struct {
 	void*                         address;
 #if !defined(__LP64__)
 	mach_msg_size_t               count;
@@ -359,7 +363,7 @@ typedef struct{
 #endif
 } mach_msg_ool_ports_descriptor_t;
 
-typedef struct{
+typedef struct {
 	uint32_t                      context;
 	mach_port_name_t              name;
 	mach_msg_guard_flags_t        flags : 16;
@@ -367,7 +371,7 @@ typedef struct{
 	mach_msg_descriptor_type_t    type : 8;
 } mach_msg_guarded_port_descriptor32_t;
 
-typedef struct{
+typedef struct {
 	uint64_t                      context;
 	mach_msg_guard_flags_t        flags : 16;
 	mach_msg_type_name_t          disposition : 8;
@@ -375,7 +379,7 @@ typedef struct{
 	mach_port_name_t              name;
 } mach_msg_guarded_port_descriptor64_t;
 
-typedef struct{
+typedef struct {
 	mach_port_context_t           context;
 #if !defined(__LP64__)
 	mach_port_name_t              name;
@@ -401,30 +405,32 @@ typedef union{
 	mach_msg_guarded_port_descriptor_t    guarded_port;
 } mach_msg_descriptor_t;
 
-typedef struct{
+typedef struct {
 	mach_msg_size_t msgh_descriptor_count;
 } mach_msg_body_t;
 
-#define MACH_MSG_BODY_NULL (mach_msg_body_t *) 0
-#define MACH_MSG_DESCRIPTOR_NULL (mach_msg_descriptor_t *) 0
+#define MACH_MSG_BODY_NULL            ((mach_msg_body_t *) 0)
+#define MACH_MSG_DESCRIPTOR_NULL      ((mach_msg_descriptor_t *) 0)
 
-typedef struct{
-	mach_msg_bits_t       msgh_bits;
-	mach_msg_size_t       msgh_size;
-	mach_port_t           msgh_remote_port;
-	mach_port_t           msgh_local_port;
-	mach_port_name_t      msgh_voucher_port;
-	mach_msg_id_t         msgh_id;
+typedef struct {
+	mach_msg_bits_t               msgh_bits;
+	mach_msg_size_t               msgh_size;
+	mach_port_t                   msgh_remote_port;
+	mach_port_t                   msgh_local_port;
+	mach_port_name_t              msgh_voucher_port;
+	mach_msg_id_t                 msgh_id;
 } mach_msg_header_t;
 
-#define msgh_reserved           msgh_voucher_port
-#define MACH_MSG_NULL   (mach_msg_header_t *) 0
 
-typedef struct{
-	mach_msg_header_t       header;
-	mach_msg_body_t         body;
+#define msgh_reserved                 msgh_voucher_port
+#define MACH_MSG_NULL                 ((mach_msg_header_t *) 0)
+
+typedef struct {
+	mach_msg_header_t             header;
+	mach_msg_body_t               body;
 } mach_msg_base_t;
 
+
 typedef unsigned int mach_msg_trailer_type_t;
 
 #define MACH_MSG_TRAILER_FORMAT_0       0
@@ -432,7 +438,7 @@ typedef unsigned int mach_msg_trailer_type_t;
 typedef unsigned int mach_msg_trailer_size_t;
 typedef char *mach_msg_trailer_info_t;
 
-typedef struct{
+typedef struct {
 	mach_msg_trailer_type_t       msgh_trailer_type;
 	mach_msg_trailer_size_t       msgh_trailer_size;
 } mach_msg_trailer_t;
@@ -446,17 +452,17 @@ typedef struct{
  *  multiple threads receive and/or process received
  *  messages.
  */
-typedef struct{
+typedef struct {
 	mach_msg_trailer_type_t       msgh_trailer_type;
 	mach_msg_trailer_size_t       msgh_trailer_size;
 	mach_port_seqno_t             msgh_seqno;
 } mach_msg_seqno_trailer_t;
 
-typedef struct{
+typedef struct {
 	unsigned int                  val[2];
 } security_token_t;
 
-typedef struct{
+typedef struct {
 	mach_msg_trailer_type_t       msgh_trailer_type;
 	mach_msg_trailer_size_t       msgh_trailer_size;
 	mach_port_seqno_t             msgh_seqno;
@@ -472,11 +478,11 @@ typedef struct{
  * of the subject identity within the token may change
  * over time.
  */
-typedef struct{
+typedef struct {
 	unsigned int                  val[8];
 } audit_token_t;
 
-typedef struct{
+typedef struct {
 	mach_msg_trailer_type_t       msgh_trailer_type;
 	mach_msg_trailer_size_t       msgh_trailer_size;
 	mach_port_seqno_t             msgh_seqno;
@@ -484,7 +490,7 @@ typedef struct{
 	audit_token_t                 msgh_audit;
 } mach_msg_audit_trailer_t;
 
-typedef struct{
+typedef struct {
 	mach_msg_trailer_type_t       msgh_trailer_type;
 	mach_msg_trailer_size_t       msgh_trailer_size;
 	mach_port_seqno_t             msgh_seqno;
@@ -495,23 +501,26 @@ typedef struct{
 
 
 
-typedef struct{
+typedef struct {
 	mach_port_name_t sender;
 } msg_labels_t;
 
+typedef int mach_msg_filter_id;
+#define MACH_MSG_FILTER_POLICY_ALLOW (mach_msg_filter_id)0
+
 /*
  *  Trailer type to pass MAC policy label info as a mach message trailer.
  *
  */
 
-typedef struct{
+typedef struct {
 	mach_msg_trailer_type_t       msgh_trailer_type;
 	mach_msg_trailer_size_t       msgh_trailer_size;
 	mach_port_seqno_t             msgh_seqno;
 	security_token_t              msgh_sender;
 	audit_token_t                 msgh_audit;
 	mach_port_context_t           msgh_context;
-	int                           msgh_ad;
+	mach_msg_filter_id            msgh_ad;
 	msg_labels_t                  msgh_labels;
 } mach_msg_mac_trailer_t;
 
@@ -553,11 +562,13 @@ extern const audit_token_t KERNEL_AUDIT_TOKEN;
 
 typedef integer_t mach_msg_options_t;
 
-typedef struct{
+#define MACH_MSG_HEADER_EMPTY (mach_msg_header_t){ }
+
+typedef struct {
 	mach_msg_header_t     header;
 } mach_msg_empty_send_t;
 
-typedef struct{
+typedef struct {
 	mach_msg_header_t     header;
 	mach_msg_trailer_t    trailer;
 } mach_msg_empty_rcv_t;
@@ -658,11 +669,12 @@ typedef integer_t mach_msg_option_t;
 #define MACH_SEND_INTERRUPT     0x00000040      /* don't restart interrupted sends */
 #define MACH_SEND_NOTIFY        0x00000080      /* arm send-possible notify */
 #define MACH_SEND_ALWAYS        0x00010000      /* ignore qlimits - kernel only */
+#define MACH_SEND_FILTER_NONFATAL        0x00010000      /* rejection by message filter should return failure - user only */
 #define MACH_SEND_TRAILER       0x00020000      /* sender-provided trailer */
 #define MACH_SEND_NOIMPORTANCE  0x00040000      /* msg won't carry importance */
 #define MACH_SEND_NODENAP       MACH_SEND_NOIMPORTANCE
 #define MACH_SEND_IMPORTANCE    0x00080000      /* msg carries importance - kernel only */
-#define MACH_SEND_SYNC_OVERRIDE 0x00100000      /* msg should do sync ipc override */
+#define MACH_SEND_SYNC_OVERRIDE 0x00100000      /* msg should do sync IPC override (on legacy kernels) */
 #define MACH_SEND_PROPAGATE_QOS 0x00200000      /* IPC should propagate the caller's QoS */
 #define MACH_SEND_SYNC_USE_THRPRI       MACH_SEND_PROPAGATE_QOS /* obsolete name */
 #define MACH_SEND_KERNEL        0x00400000      /* full send from kernel space - kernel only */
@@ -795,10 +807,18 @@ typedef kern_return_t mach_msg_return_t;
 /* The trailer to be sent does not match kernel format. */
 #define MACH_SEND_INVALID_CONTEXT       0x10000012
 /* The sending thread context did not match the context on the dest port */
+#define MACH_SEND_INVALID_OPTIONS       0x10000013
+/* Send options are invalid. */
 #define MACH_SEND_INVALID_RT_OOL_SIZE   0x10000015
 /* compatibility: no longer a returned error */
 #define MACH_SEND_NO_GRANT_DEST         0x10000016
 /* The destination port doesn't accept ports in body */
+#define MACH_SEND_MSG_FILTERED          0x10000017
+/* Message send was rejected by message filter */
+#define MACH_SEND_AUX_TOO_SMALL         0x10000018
+/* Message auxiliary data is too small */
+#define MACH_SEND_AUX_TOO_LARGE         0x10000019
+/* Message auxiliary data is too large */
 
 #define MACH_RCV_IN_PROGRESS            0x10004001
 /* Thread is waiting for receive.  (Internal use only.) */
@@ -834,6 +854,8 @@ typedef kern_return_t mach_msg_return_t;
 /* Waiting for receive with timeout. (Internal use only.) */
 #define MACH_RCV_INVALID_REPLY          0x10004012
 /* invalid reply port used in a STRICT_REPLY message */
+#define MACH_RCV_INVALID_ARGUMENTS      0x10004013
+/* invalid receive arguments, receive has not started */
 
 
 
@@ -886,11 +908,12 @@ extern mach_msg_return_t        mach_msg(
 	mach_msg_timeout_t timeout,
 	mach_port_name_t notify);
 
+
 /*
- *	Routine:	mach_voucher_deallocate
- *	Purpose:
- *		Deallocate a mach voucher created or received in a message.  Drops
- *		one (send right) reference to the voucher.
+ *  Routine:    mach_voucher_deallocate
+ *  Purpose:
+ *      Deallocate a mach voucher created or received in a message.  Drops
+ *      one (send right) reference to the voucher.
  */
 __WATCHOS_PROHIBITED __TVOS_PROHIBITED
 extern kern_return_t            mach_voucher_deallocate(
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/port.h b/lib/libc/include/any-macos.13-any/mach/port.h
similarity index 80%
rename from lib/libc/include/x86_64-macos.10-none/mach/port.h
rename to lib/libc/include/any-macos.13-any/mach/port.h
index 3547576e80..effc74aba4 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/port.h
+++ b/lib/libc/include/any-macos.13-any/mach/port.h
@@ -211,7 +211,6 @@ typedef mach_port_type_t *mach_port_type_array_t;
 #define MACH_PORT_TYPE_LABELH       MACH_PORT_TYPE(MACH_PORT_RIGHT_LABELH) /* obsolete */
 
 
-
 /* Convenient combinations. */
 
 #define MACH_PORT_TYPE_SEND_RECEIVE                                     \
@@ -293,9 +292,13 @@ typedef struct mach_port_info_ext {
 	uint32_t                reserved[6];
 } mach_port_info_ext_t;
 
+typedef struct mach_port_guard_info {
+	uint64_t    mpgi_guard;     /* guard value */
+} mach_port_guard_info_t;
+
 typedef integer_t *mach_port_info_t;            /* varying array of natural_t */
 
-/* Flavors for mach_port_get/set_attributes() */
+/* Flavors for mach_port_get/set/assert_attributes() */
 typedef int     mach_port_flavor_t;
 #define MACH_PORT_LIMITS_INFO           1       /* uses mach_port_limits_t */
 #define MACH_PORT_RECEIVE_STATUS        2       /* uses mach_port_status_t */
@@ -304,6 +307,7 @@ typedef int     mach_port_flavor_t;
 #define MACH_PORT_IMPORTANCE_RECEIVER   5       /* indicates recieve right accepts priority donation */
 #define MACH_PORT_DENAP_RECEIVER        6       /* indicates receive right accepts de-nap donation */
 #define MACH_PORT_INFO_EXT              7       /* uses mach_port_info_ext_t */
+#define MACH_PORT_GUARD_INFO            8       /* asserts if the strict guard value is correct */
 
 #define MACH_PORT_LIMITS_INFO_COUNT     ((natural_t) \
 	(sizeof(mach_port_limits_t)/sizeof(natural_t)))
@@ -312,6 +316,9 @@ typedef int     mach_port_flavor_t;
 #define MACH_PORT_DNREQUESTS_SIZE_COUNT 1
 #define MACH_PORT_INFO_EXT_COUNT        ((natural_t) \
 	(sizeof(mach_port_info_ext_t)/sizeof(natural_t)))
+#define MACH_PORT_GUARD_INFO_COUNT      ((natural_t) \
+	(sizeof(mach_port_guard_info_t)/sizeof(natural_t)))
+
 /*
  * Structure used to pass information about port allocation requests.
  * Must be padded to 64-bits total length.
@@ -323,7 +330,20 @@ typedef struct mach_port_qos {
 	natural_t               len;
 } mach_port_qos_t;
 
-/* Mach Port Guarding definitions */
+/*
+ * Structure used to pass information about the service port
+ */
+#define MACH_SERVICE_PORT_INFO_STRING_NAME_MAX_BUF_LEN  255    /* Maximum length of the port string name buffer */
+
+typedef struct mach_service_port_info {
+	char                    mspi_string_name[MACH_SERVICE_PORT_INFO_STRING_NAME_MAX_BUF_LEN]; /* Service port's string name */
+	uint8_t                 mspi_domain_type;          /* Service port domain */
+} mach_service_port_info_data_t;
+
+#define MACH_SERVICE_PORT_INFO_COUNT ((char) \
+	(sizeof(mach_service_port_info_data_t)/sizeof(char)))
+
+typedef struct mach_service_port_info * mach_service_port_info_t;
 
 /*
  * Flags for mach_port_options (used for
@@ -331,14 +351,23 @@ typedef struct mach_port_qos {
  * Indicates attributes to be set for the newly
  * allocated port.
  */
-#define MPO_CONTEXT_AS_GUARD    0x01    /* Add guard to the port */
-#define MPO_QLIMIT              0x02    /* Set qlimit for the port msg queue */
-#define MPO_TEMPOWNER           0x04    /* Set the tempowner bit of the port */
-#define MPO_IMPORTANCE_RECEIVER 0x08    /* Mark the port as importance receiver */
-#define MPO_INSERT_SEND_RIGHT   0x10    /* Insert a send right for the port */
-#define MPO_STRICT              0x20    /* Apply strict guarding for port */
-#define MPO_DENAP_RECEIVER      0x40    /* Mark the port as App de-nap receiver */
-#define MPO_IMMOVABLE_RECEIVE   0x80    /* Mark the port as immovable; protected by the guard context */
+#define MPO_CONTEXT_AS_GUARD               0x01    /* Add guard to the port */
+#define MPO_QLIMIT                         0x02    /* Set qlimit for the port msg queue */
+#define MPO_TEMPOWNER                      0x04    /* Set the tempowner bit of the port */
+#define MPO_IMPORTANCE_RECEIVER            0x08    /* Mark the port as importance receiver */
+#define MPO_INSERT_SEND_RIGHT              0x10    /* Insert a send right for the port */
+#define MPO_STRICT                         0x20    /* Apply strict guarding for port */
+#define MPO_DENAP_RECEIVER                 0x40    /* Mark the port as App de-nap receiver */
+#define MPO_IMMOVABLE_RECEIVE              0x80    /* Mark the port as immovable; protected by the guard context */
+#define MPO_FILTER_MSG                     0x100   /* Allow message filtering */
+#define MPO_TG_BLOCK_TRACKING              0x200   /* Track blocking relationship for thread group during sync IPC */
+#define MPO_SERVICE_PORT                   0x400   /* Create a service port with the given name; should be used only by launchd */
+#define MPO_CONNECTION_PORT                0x800   /* Derive new peer connection port from a given service port */
+#define MPO_REPLY_PORT                     0x1000  /* Designate port as a reply port. */
+#define MPO_ENFORCE_REPLY_PORT_SEMANTICS   0x2000  /* When talking to this port, local port of mach msg needs to follow reply port semantics.*/
+#define MPO_PROVISIONAL_REPLY_PORT         0x4000  /* Designate port as a provisional reply port. */
+
+
 /*
  * Structure to define optional attributes for a newly
  * constructed port.
@@ -346,11 +375,18 @@ typedef struct mach_port_qos {
 typedef struct mach_port_options {
 	uint32_t                flags;          /* Flags defining attributes for port */
 	mach_port_limits_t      mpl;            /* Message queue limit for port */
-	uint64_t                reserved[2];    /* Reserved */
+	union {
+		uint64_t                   reserved[2];           /* Reserved */
+		mach_port_name_t           work_interval_port;    /* Work interval port */
+		mach_service_port_info_t   service_port_info;     /* Service port (MPO_SERVICE_PORT) */
+		mach_port_name_t           service_port_name;     /* Service port (MPO_CONNECTION_PORT) */
+	};
 }mach_port_options_t;
 
 typedef mach_port_options_t *mach_port_options_ptr_t;
 
+/* Mach Port Guarding definitions */
+
 /*
  * EXC_GUARD represents a guard violation for both
  * mach ports and file descriptors. GUARD_TYPE_ is used
@@ -360,13 +396,15 @@ typedef mach_port_options_t *mach_port_options_ptr_t;
 
 /* Reasons for exception for a guarded mach port */
 enum mach_port_guard_exception_codes {
-	kGUARD_EXC_DESTROY                       = 1u << 0,
-	kGUARD_EXC_MOD_REFS                      = 1u << 1,
-	kGUARD_EXC_SET_CONTEXT               = 1u << 2,
+	kGUARD_EXC_DESTROY                   = 1,
+	kGUARD_EXC_MOD_REFS                  = 2,
+	kGUARD_EXC_INVALID_OPTIONS           = 3,
+	kGUARD_EXC_SET_CONTEXT               = 4,
 	kGUARD_EXC_UNGUARDED                 = 1u << 3,
 	kGUARD_EXC_INCORRECT_GUARD           = 1u << 4,
 	kGUARD_EXC_IMMOVABLE                 = 1u << 5,
 	kGUARD_EXC_STRICT_REPLY              = 1u << 6,
+	kGUARD_EXC_MSG_FILTERED              = 1u << 7,
 	/* start of [optionally] non-fatal guards */
 	kGUARD_EXC_INVALID_RIGHT         = 1u << 8,
 	kGUARD_EXC_INVALID_NAME          = 1u << 9,
@@ -380,10 +418,21 @@ enum mach_port_guard_exception_codes {
 	kGUARD_EXC_SEND_INVALID_VOUCHER  = 1u << 17,
 	kGUARD_EXC_SEND_INVALID_RIGHT    = 1u << 18,
 	kGUARD_EXC_RCV_INVALID_NAME      = 1u << 19,
-	kGUARD_EXC_RCV_GUARDED_DESC      = 1u << 20, /* should never be fatal; for development only */
+	/* start of always non-fatal guards */
+	kGUARD_EXC_RCV_GUARDED_DESC             = 1u << 20, /* for development only */
+	kGUARD_EXC_MOD_REFS_NON_FATAL           = 1u << 21,
+	kGUARD_EXC_IMMOVABLE_NON_FATAL          = 1u << 22,
+	kGUARD_EXC_REQUIRE_REPLY_PORT_SEMANTICS = 1u << 23,
 };
 
-#define MAX_FATAL_kGUARD_EXC_CODE (1u << 6)
+#define MAX_FATAL_kGUARD_EXC_CODE (1u << 7)
+
+/*
+ * Mach port guard flags.
+ */
+#define MPG_FLAGS_NONE                             (0x00ull)
+
+#define MAX_OPTIONAL_kGUARD_EXC_CODE (1u << 19)
 
 /*
  * These flags are used as bits in the subcode of kGUARD_EXC_STRICT_REPLY exceptions.
@@ -395,6 +444,18 @@ enum mach_port_guard_exception_codes {
 #define MPG_FLAGS_STRICT_REPLY_MISMATCHED_PERSONA  (0x10ull << 56)
 #define MPG_FLAGS_STRICT_REPLY_MASK                (0xffull << 56)
 
+/*
+ * These flags are used as bits in the subcode of kGUARD_EXC_MOD_REFS exceptions.
+ */
+#define MPG_FLAGS_MOD_REFS_PINNED_DEALLOC          (0x01ull << 56)
+#define MPG_FLAGS_MOD_REFS_PINNED_DESTROY          (0x02ull << 56)
+#define MPG_FLAGS_MOD_REFS_PINNED_COPYIN           (0x04ull << 56)
+
+/*
+ * These flags are used as bits in the subcode of kGUARD_EXC_IMMOVABLE exceptions.
+ */
+#define MPG_FLAGS_IMMOVABLE_PINNED                 (0x01ull << 56)
+
 /*
  * Flags for mach_port_guard_with_flags. These flags extend
  * the attributes associated with a guarded port.
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/processor.h b/lib/libc/include/any-macos.13-any/mach/processor.h
similarity index 96%
rename from lib/libc/include/x86_64-macos.10-none/mach/processor.h
rename to lib/libc/include/any-macos.13-any/mach/processor.h
index 64cf6b97b3..054f258910 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/processor.h
+++ b/lib/libc/include/any-macos.13-any/mach/processor.h
@@ -25,7 +25,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
+#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_ATTR
+#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_COUNTEDBY_ATTR(C) __unsafe_indexable
+#endif
+	extern int mig_strncpy_zerofill(char * dest, const char * src, int len) __attribute__((weak_import));
 #ifdef __cplusplus
 }
 #endif
@@ -41,7 +44,7 @@ extern "C" {
 #define FUNCTION_PTR_T
 typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
 typedef struct {
-        char            *name;
+        char            * name;
         function_ptr_t  function;
 } function_table_entry;
 typedef function_table_entry   *function_table_t;
@@ -52,6 +55,7 @@ typedef function_table_entry   *function_table_t;
 #define	processor_MSG_COUNT	6
 #endif	/* processor_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>
diff --git a/lib/libc/include/any-macos.13-any/mach/processor_info.h b/lib/libc/include/any-macos.13-any/mach/processor_info.h
new file mode 100644
index 0000000000..31bc0e8929
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/mach/processor_info.h
@@ -0,0 +1,156 @@
+/*
+ * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+/*
+ * @OSF_COPYRIGHT@
+ */
+/*
+ * Mach Operating System
+ * Copyright (c) 1991,1990,1989 Carnegie Mellon University
+ * All Rights Reserved.
+ *
+ * Permission to use, copy, modify and distribute this software and its
+ * documentation is hereby granted, provided that both the copyright
+ * notice and this permission notice appear in all copies of the
+ * software, derivative works or modified versions, and any portions
+ * thereof, and that both notices appear in supporting documentation.
+ *
+ * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
+ * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ *
+ * Carnegie Mellon requests users of this software to return to
+ *
+ *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
+ *  School of Computer Science
+ *  Carnegie Mellon University
+ *  Pittsburgh PA 15213-3890
+ *
+ * any improvements or extensions that they make and grant Carnegie Mellon
+ * the rights to redistribute these changes.
+ */
+/*
+ */
+
+/*
+ *	File:	mach/processor_info.h
+ *	Author:	David L. Black
+ *	Date:	1988
+ *
+ *	Data structure definitions for processor_info, processor_set_info
+ */
+
+#ifndef _MACH_PROCESSOR_INFO_H_
+#define _MACH_PROCESSOR_INFO_H_
+
+#include <mach/message.h>
+#include <mach/machine.h>
+#include <mach/machine/processor_info.h>
+
+/*
+ *	Generic information structure to allow for expansion.
+ */
+typedef integer_t       *processor_info_t;      /* varying array of int. */
+typedef integer_t       *processor_info_array_t;  /* varying array of int */
+
+#define PROCESSOR_INFO_MAX      (1024)  /* max array size */
+typedef integer_t       processor_info_data_t[PROCESSOR_INFO_MAX];
+
+
+typedef integer_t       *processor_set_info_t;  /* varying array of int. */
+
+#define PROCESSOR_SET_INFO_MAX  (1024)  /* max array size */
+typedef integer_t       processor_set_info_data_t[PROCESSOR_SET_INFO_MAX];
+
+/*
+ *	Currently defined information.
+ */
+typedef int     processor_flavor_t;
+#define PROCESSOR_BASIC_INFO    1               /* basic information */
+#define PROCESSOR_CPU_LOAD_INFO 2       /* cpu load information */
+#define PROCESSOR_PM_REGS_INFO  0x10000001      /* performance monitor register info */
+#define PROCESSOR_TEMPERATURE   0x10000002      /* Processor core temperature */
+
+struct processor_basic_info {
+	cpu_type_t      cpu_type;       /* type of cpu */
+	cpu_subtype_t   cpu_subtype;    /* subtype of cpu */
+	boolean_t       running;        /* is processor running */
+	int             slot_num;       /* slot number */
+	union {
+		boolean_t       is_master;  /* deprecated */
+		boolean_t       is_main;    /* is this the main processor */
+	};
+};
+
+typedef struct processor_basic_info     processor_basic_info_data_t;
+typedef struct processor_basic_info     *processor_basic_info_t;
+#define PROCESSOR_BASIC_INFO_COUNT      ((mach_msg_type_number_t) \
+	        (sizeof(processor_basic_info_data_t)/sizeof(natural_t)))
+
+struct processor_cpu_load_info {             /* number of ticks while running... */
+	unsigned int    cpu_ticks[CPU_STATE_MAX]; /* ... in the given mode */
+};
+
+typedef struct processor_cpu_load_info  processor_cpu_load_info_data_t;
+typedef struct processor_cpu_load_info  *processor_cpu_load_info_t;
+#define PROCESSOR_CPU_LOAD_INFO_COUNT   ((mach_msg_type_number_t) \
+	        (sizeof(processor_cpu_load_info_data_t)/sizeof(natural_t)))
+
+/*
+ *	Scaling factor for load_average, mach_factor.
+ */
+#define LOAD_SCALE      1000
+
+typedef int     processor_set_flavor_t;
+#define PROCESSOR_SET_BASIC_INFO        5       /* basic information */
+
+struct processor_set_basic_info {
+	int             processor_count;        /* How many processors */
+	int             default_policy;         /* When others not enabled */
+};
+
+typedef struct processor_set_basic_info processor_set_basic_info_data_t;
+typedef struct processor_set_basic_info *processor_set_basic_info_t;
+#define PROCESSOR_SET_BASIC_INFO_COUNT  ((mach_msg_type_number_t) \
+	        (sizeof(processor_set_basic_info_data_t)/sizeof(natural_t)))
+
+#define PROCESSOR_SET_LOAD_INFO         4       /* scheduling statistics */
+
+struct processor_set_load_info {
+	int             task_count;             /* How many tasks */
+	int             thread_count;           /* How many threads */
+	integer_t       load_average;           /* Scaled */
+	integer_t       mach_factor;            /* Scaled */
+};
+
+typedef struct processor_set_load_info processor_set_load_info_data_t;
+typedef struct processor_set_load_info *processor_set_load_info_t;
+#define PROCESSOR_SET_LOAD_INFO_COUNT   ((mach_msg_type_number_t) \
+	        (sizeof(processor_set_load_info_data_t)/sizeof(natural_t)))
+
+
+#endif  /* _MACH_PROCESSOR_INFO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/processor_set.h b/lib/libc/include/any-macos.13-any/mach/processor_set.h
similarity index 89%
rename from lib/libc/include/x86_64-macos.10-none/mach/processor_set.h
rename to lib/libc/include/any-macos.13-any/mach/processor_set.h
index c7637d1f19..49fcfbd233 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/processor_set.h
+++ b/lib/libc/include/any-macos.13-any/mach/processor_set.h
@@ -25,7 +25,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
+#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_ATTR
+#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_COUNTEDBY_ATTR(C) __unsafe_indexable
+#endif
+	extern int mig_strncpy_zerofill(char * dest, const char * src, int len) __attribute__((weak_import));
 #ifdef __cplusplus
 }
 #endif
@@ -41,7 +44,7 @@ extern "C" {
 #define FUNCTION_PTR_T
 typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
 typedef struct {
-        char            *name;
+        char            * name;
         function_ptr_t  function;
 } function_table_entry;
 typedef function_table_entry   *function_table_t;
@@ -49,9 +52,10 @@ typedef function_table_entry   *function_table_t;
 #endif /* AUTOTEST */
 
 #ifndef	processor_set_MSG_COUNT
-#define	processor_set_MSG_COUNT	10
+#define	processor_set_MSG_COUNT	11
 #endif	/* processor_set_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>
@@ -200,6 +204,20 @@ kern_return_t processor_set_info
 	mach_msg_type_number_t *info_outCnt
 );
 
+/* Routine processor_set_tasks_with_flavor */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t processor_set_tasks_with_flavor
+(
+	processor_set_t processor_set,
+	mach_task_flavor_t flavor,
+	task_array_t *task_list,
+	mach_msg_type_number_t *task_listCnt
+);
+
 __END_DECLS
 
 /********************** Caution **************************/
@@ -336,6 +354,18 @@ __END_DECLS
 #ifdef  __MigPackStructs
 #pragma pack(pop)
 #endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		mach_task_flavor_t flavor;
+	} __Request__processor_set_tasks_with_flavor_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
 #endif /* !__Request__processor_set_subsystem__defined */
 
 /* union of all requests */
@@ -353,6 +383,7 @@ union __RequestUnion__processor_set_subsystem {
 	__Request__processor_set_policy_control_t Request_processor_set_policy_control;
 	__Request__processor_set_stack_usage_t Request_processor_set_stack_usage;
 	__Request__processor_set_info_t Request_processor_set_info;
+	__Request__processor_set_tasks_with_flavor_t Request_processor_set_tasks_with_flavor;
 };
 #endif /* !__RequestUnion__processor_set_subsystem__defined */
 /* typedefs for all replies */
@@ -499,6 +530,22 @@ union __RequestUnion__processor_set_subsystem {
 #ifdef  __MigPackStructs
 #pragma pack(pop)
 #endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_ool_ports_descriptor_t task_list;
+		/* end of the kernel processed data */
+		NDR_record_t NDR;
+		mach_msg_type_number_t task_listCnt;
+	} __Reply__processor_set_tasks_with_flavor_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
 #endif /* !__Reply__processor_set_subsystem__defined */
 
 /* union of all replies */
@@ -516,6 +563,7 @@ union __ReplyUnion__processor_set_subsystem {
 	__Reply__processor_set_policy_control_t Reply_processor_set_policy_control;
 	__Reply__processor_set_stack_usage_t Reply_processor_set_stack_usage;
 	__Reply__processor_set_info_t Reply_processor_set_info;
+	__Reply__processor_set_tasks_with_flavor_t Reply_processor_set_tasks_with_flavor;
 };
 #endif /* !__RequestUnion__processor_set_subsystem__defined */
 
@@ -530,7 +578,8 @@ union __ReplyUnion__processor_set_subsystem {
     { "processor_set_threads", 4006 },\
     { "processor_set_policy_control", 4007 },\
     { "processor_set_stack_usage", 4008 },\
-    { "processor_set_info", 4009 }
+    { "processor_set_info", 4009 },\
+    { "processor_set_tasks_with_flavor", 4010 }
 #endif
 
 #ifdef __AfterMigUserHeader
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/task.h b/lib/libc/include/any-macos.13-any/mach/task.h
similarity index 83%
rename from lib/libc/include/x86_64-macos.10-none/mach/task.h
rename to lib/libc/include/any-macos.13-any/mach/task.h
index 5f0de2dcd5..2fd8ea9876 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/task.h
+++ b/lib/libc/include/any-macos.13-any/mach/task.h
@@ -25,7 +25,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
+#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_ATTR
+#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_COUNTEDBY_ATTR(C) __unsafe_indexable
+#endif
+	extern int mig_strncpy_zerofill(char * dest, const char * src, int len) __attribute__((weak_import));
 #ifdef __cplusplus
 }
 #endif
@@ -41,7 +44,7 @@ extern "C" {
 #define FUNCTION_PTR_T
 typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
 typedef struct {
-        char            *name;
+        char            * name;
         function_ptr_t  function;
 } function_table_entry;
 typedef function_table_entry   *function_table_t;
@@ -49,9 +52,10 @@ typedef function_table_entry   *function_table_t;
 #endif /* AUTOTEST */
 
 #ifndef	task_MSG_COUNT
-#define	task_MSG_COUNT	55
+#define	task_MSG_COUNT	65
 #endif	/* task_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>
@@ -111,8 +115,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t mach_ports_register
 (
 	task_t target_task,
@@ -126,8 +129,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t mach_ports_lookup
 (
 	task_t target_task,
@@ -155,8 +157,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_set_info
 (
 	task_t target_task,
@@ -171,11 +172,10 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_suspend
 (
-	task_t target_task
+	task_read_t target_task
 );
 
 /* Routine task_resume */
@@ -184,11 +184,10 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_resume
 (
-	task_t target_task
+	task_read_t target_task
 );
 
 /* Routine task_get_special_port */
@@ -197,8 +196,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_get_special_port
 (
 	task_inspect_t task,
@@ -212,8 +210,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_set_special_port
 (
 	task_t task,
@@ -227,8 +224,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t thread_create
 (
 	task_t parent_task,
@@ -241,8 +237,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t thread_create_running
 (
 	task_t parent_task,
@@ -258,8 +253,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_set_exception_ports
 (
 	task_t task,
@@ -275,11 +269,10 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_get_exception_ports
 (
-	task_inspect_t task,
+	task_t task,
 	exception_mask_t exception_mask,
 	exception_mask_array_t masks,
 	mach_msg_type_number_t *masksCnt,
@@ -294,8 +287,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_swap_exception_ports
 (
 	task_t task,
@@ -305,7 +297,7 @@ kern_return_t task_swap_exception_ports
 	thread_state_flavor_t new_flavor,
 	exception_mask_array_t masks,
 	mach_msg_type_number_t *masksCnt,
-	exception_handler_array_t old_handlerss,
+	exception_handler_array_t old_handlers,
 	exception_behavior_array_t old_behaviors,
 	exception_flavor_array_t old_flavors
 );
@@ -368,11 +360,10 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_policy_set
 (
-	task_t task,
+	task_policy_set_t task,
 	task_policy_flavor_t flavor,
 	task_policy_t policy_info,
 	mach_msg_type_number_t policy_infoCnt
@@ -384,11 +375,10 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_policy_get
 (
-	task_t task,
+	task_policy_get_t task,
 	task_policy_flavor_t flavor,
 	task_policy_t policy_info,
 	mach_msg_type_number_t *policy_infoCnt,
@@ -483,11 +473,10 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_zone_info
 (
-	task_t target_task,
+	task_inspect_t target_task,
 	mach_zone_name_array_t *names,
 	mach_msg_type_number_t *namesCnt,
 	task_zone_info_array_t *info,
@@ -527,7 +516,7 @@ extern
 #endif	/* mig_external */
 kern_return_t task_get_assignment
 (
-	task_t task,
+	task_inspect_t task,
 	processor_set_name_t *assigned_set
 );
 
@@ -555,11 +544,10 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_get_state
 (
-	task_t task,
+	task_read_t task,
 	thread_state_flavor_t flavor,
 	thread_state_t old_state,
 	mach_msg_type_number_t *old_stateCnt
@@ -571,8 +559,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_set_state
 (
 	task_t task,
@@ -587,8 +574,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_set_phys_footprint_limit
 (
 	task_t task,
@@ -602,11 +588,10 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_suspend2
 (
-	task_t target_task,
+	task_read_t target_task,
 	task_suspension_token_t *suspend_token
 );
 
@@ -616,8 +601,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_resume2
 (
 	task_suspension_token_t suspend_token
@@ -631,7 +615,7 @@ extern
 #endif	/* mig_external */
 kern_return_t task_purgable_info
 (
-	task_t task,
+	task_inspect_t task,
 	task_purgable_info_t *stats
 );
 
@@ -641,11 +625,10 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_get_mach_voucher
 (
-	task_t task,
+	task_read_t task,
 	mach_voucher_selector_t which,
 	ipc_voucher_t *voucher
 );
@@ -656,8 +639,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_set_mach_voucher
 (
 	task_t task,
@@ -670,8 +652,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_swap_mach_voucher
 (
 	task_t task,
@@ -687,7 +668,7 @@ extern
 #endif	/* mig_external */
 kern_return_t task_generate_corpse
 (
-	task_t task,
+	task_read_t task,
 	mach_port_t *corpse_task_port
 );
 
@@ -700,7 +681,7 @@ extern
 kern_return_t task_map_corpse_info
 (
 	task_t task,
-	task_t corspe_task,
+	task_read_t corspe_task,
 	vm_address_t *kcd_addr_begin,
 	uint32_t *kcd_size
 );
@@ -739,7 +720,7 @@ extern
 #endif	/* mig_external */
 kern_return_t task_get_dyld_image_infos
 (
-	task_inspect_t task,
+	task_read_t task,
 	dyld_kernel_image_info_array_t *dyld_images,
 	mach_msg_type_number_t *dyld_imagesCnt
 );
@@ -791,7 +772,7 @@ extern
 kern_return_t task_map_corpse_info_64
 (
 	task_t task,
-	task_t corspe_task,
+	task_read_t corspe_task,
 	mach_vm_address_t *kcd_addr_begin,
 	mach_vm_size_t *kcd_size
 );
@@ -834,18 +815,122 @@ kern_return_t task_set_exc_guard_behavior
 	task_exc_guard_behavior_t behavior
 );
 
-/* Routine task_create_suid_cred */
+/* Routine task_dyld_process_info_notify_register */
 #ifdef	mig_external
 mig_external
 #else
 extern
 #endif	/* mig_external */
-kern_return_t task_create_suid_cred
+kern_return_t task_dyld_process_info_notify_register
+(
+	task_read_t target_task,
+	mach_port_t notify
+);
+
+/* Routine task_create_identity_token */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t task_create_identity_token
 (
 	task_t task,
-	suid_cred_path_t path,
-	suid_cred_uid_t uid,
-	suid_cred_t *delegation
+	task_id_token_t *token
+);
+
+/* Routine task_identity_token_get_task_port */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t task_identity_token_get_task_port
+(
+	task_id_token_t token,
+	task_flavor_t flavor,
+	mach_port_t *task_port
+);
+
+/* Routine task_dyld_process_info_notify_deregister */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t task_dyld_process_info_notify_deregister
+(
+	task_read_t target_task,
+	mach_port_name_t notify
+);
+
+/* Routine task_get_exception_ports_info */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t task_get_exception_ports_info
+(
+	mach_port_t port,
+	exception_mask_t exception_mask,
+	exception_mask_array_t masks,
+	mach_msg_type_number_t *masksCnt,
+	exception_handler_info_array_t old_handlers_info,
+	exception_behavior_array_t old_behaviors,
+	exception_flavor_array_t old_flavors
+);
+
+/* Routine task_test_sync_upcall */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t task_test_sync_upcall
+(
+	task_t task,
+	mach_port_t port
+);
+
+/* Routine task_set_corpse_forking_behavior */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t task_set_corpse_forking_behavior
+(
+	task_t task,
+	task_corpse_forking_behavior_t behavior
+);
+
+/* Routine task_test_async_upcall_propagation */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t task_test_async_upcall_propagation
+(
+	task_t task,
+	mach_port_t port,
+	int qos,
+	int iotier
+);
+
+/* Routine task_map_kcdata_object_64 */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t task_map_kcdata_object_64
+(
+	task_t task,
+	kcdata_object_t kcdata_object,
+	mach_vm_address_t *kcd_addr_begin,
+	mach_vm_size_t *kcd_size
 );
 
 __END_DECLS
@@ -950,7 +1035,7 @@ __END_DECLS
 		NDR_record_t NDR;
 		task_flavor_t flavor;
 		mach_msg_type_number_t task_info_inCnt;
-		integer_t task_info_in[87];
+		integer_t task_info_in[90];
 	} __Request__task_set_info_t __attribute__((unused));
 #ifdef  __MigPackStructs
 #pragma pack(pop)
@@ -1022,7 +1107,7 @@ __END_DECLS
 		NDR_record_t NDR;
 		thread_state_flavor_t flavor;
 		mach_msg_type_number_t new_stateCnt;
-		natural_t new_state[614];
+		natural_t new_state[1296];
 	} __Request__thread_create_running_t __attribute__((unused));
 #ifdef  __MigPackStructs
 #pragma pack(pop)
@@ -1331,7 +1416,7 @@ __END_DECLS
 		NDR_record_t NDR;
 		thread_state_flavor_t flavor;
 		mach_msg_type_number_t new_stateCnt;
-		natural_t new_state[614];
+		natural_t new_state[1296];
 	} __Request__task_set_state_t __attribute__((unused));
 #ifdef  __MigPackStructs
 #pragma pack(pop)
@@ -1572,17 +1657,119 @@ __END_DECLS
 #pragma pack(pop)
 #endif
 
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t notify;
+		/* end of the kernel processed data */
+	} __Request__task_dyld_process_info_notify_register_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+	} __Request__task_create_identity_token_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
 #ifdef  __MigPackStructs
 #pragma pack(push, 4)
 #endif
 	typedef struct {
 		mach_msg_header_t Head;
 		NDR_record_t NDR;
-		mach_msg_type_number_t pathOffset; /* MiG doesn't use it */
-		mach_msg_type_number_t pathCnt;
-		char path[1024];
-		suid_cred_uid_t uid;
-	} __Request__task_create_suid_cred_t __attribute__((unused));
+		task_flavor_t flavor;
+	} __Request__task_identity_token_get_task_port_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		mach_port_name_t notify;
+	} __Request__task_dyld_process_info_notify_deregister_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		exception_mask_t exception_mask;
+	} __Request__task_get_exception_ports_info_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t port;
+		/* end of the kernel processed data */
+	} __Request__task_test_sync_upcall_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		task_corpse_forking_behavior_t behavior;
+	} __Request__task_set_corpse_forking_behavior_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t port;
+		/* end of the kernel processed data */
+		NDR_record_t NDR;
+		int qos;
+		int iotier;
+	} __Request__task_test_async_upcall_propagation_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t kcdata_object;
+		/* end of the kernel processed data */
+	} __Request__task_map_kcdata_object_64_t __attribute__((unused));
 #ifdef  __MigPackStructs
 #pragma pack(pop)
 #endif
@@ -1647,7 +1834,15 @@ union __RequestUnion__task_subsystem {
 	__Request__task_inspect_t Request_task_inspect;
 	__Request__task_get_exc_guard_behavior_t Request_task_get_exc_guard_behavior;
 	__Request__task_set_exc_guard_behavior_t Request_task_set_exc_guard_behavior;
-	__Request__task_create_suid_cred_t Request_task_create_suid_cred;
+	__Request__task_dyld_process_info_notify_register_t Request_task_dyld_process_info_notify_register;
+	__Request__task_create_identity_token_t Request_task_create_identity_token;
+	__Request__task_identity_token_get_task_port_t Request_task_identity_token_get_task_port;
+	__Request__task_dyld_process_info_notify_deregister_t Request_task_dyld_process_info_notify_deregister;
+	__Request__task_get_exception_ports_info_t Request_task_get_exception_ports_info;
+	__Request__task_test_sync_upcall_t Request_task_test_sync_upcall;
+	__Request__task_set_corpse_forking_behavior_t Request_task_set_corpse_forking_behavior;
+	__Request__task_test_async_upcall_propagation_t Request_task_test_async_upcall_propagation;
+	__Request__task_map_kcdata_object_64_t Request_task_map_kcdata_object_64;
 };
 #endif /* !__RequestUnion__task_subsystem__defined */
 /* typedefs for all replies */
@@ -1733,7 +1928,7 @@ union __RequestUnion__task_subsystem {
 		NDR_record_t NDR;
 		kern_return_t RetCode;
 		mach_msg_type_number_t task_info_outCnt;
-		integer_t task_info_out[87];
+		integer_t task_info_out[90];
 	} __Reply__task_info_t __attribute__((unused));
 #ifdef  __MigPackStructs
 #pragma pack(pop)
@@ -1867,7 +2062,7 @@ union __RequestUnion__task_subsystem {
 		mach_msg_header_t Head;
 		/* start of the kernel processed data */
 		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t old_handlerss[32];
+		mach_msg_port_descriptor_t old_handlers[32];
 		/* end of the kernel processed data */
 		NDR_record_t NDR;
 		mach_msg_type_number_t masksCnt;
@@ -2111,7 +2306,7 @@ union __RequestUnion__task_subsystem {
 		NDR_record_t NDR;
 		kern_return_t RetCode;
 		mach_msg_type_number_t old_stateCnt;
-		natural_t old_state[614];
+		natural_t old_state[1296];
 	} __Reply__task_get_state_t __attribute__((unused));
 #ifdef  __MigPackStructs
 #pragma pack(pop)
@@ -2379,6 +2574,18 @@ union __RequestUnion__task_subsystem {
 #pragma pack(pop)
 #endif
 
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+	} __Reply__task_dyld_process_info_notify_register_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
 #ifdef  __MigPackStructs
 #pragma pack(push, 4)
 #endif
@@ -2386,9 +2593,102 @@ union __RequestUnion__task_subsystem {
 		mach_msg_header_t Head;
 		/* start of the kernel processed data */
 		mach_msg_body_t msgh_body;
-		mach_msg_port_descriptor_t delegation;
+		mach_msg_port_descriptor_t token;
 		/* end of the kernel processed data */
-	} __Reply__task_create_suid_cred_t __attribute__((unused));
+	} __Reply__task_create_identity_token_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t task_port;
+		/* end of the kernel processed data */
+	} __Reply__task_identity_token_get_task_port_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+	} __Reply__task_dyld_process_info_notify_deregister_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		mach_msg_type_number_t masksCnt;
+		exception_mask_t masks[32];
+		exception_handler_info_t old_handlers_info[32];
+		exception_behavior_t old_behaviors[32];
+		thread_state_flavor_t old_flavors[32];
+	} __Reply__task_get_exception_ports_info_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+	} __Reply__task_test_sync_upcall_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+	} __Reply__task_set_corpse_forking_behavior_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+	} __Reply__task_test_async_upcall_propagation_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		mach_vm_address_t kcd_addr_begin;
+		mach_vm_size_t kcd_size;
+	} __Reply__task_map_kcdata_object_64_t __attribute__((unused));
 #ifdef  __MigPackStructs
 #pragma pack(pop)
 #endif
@@ -2453,7 +2753,15 @@ union __ReplyUnion__task_subsystem {
 	__Reply__task_inspect_t Reply_task_inspect;
 	__Reply__task_get_exc_guard_behavior_t Reply_task_get_exc_guard_behavior;
 	__Reply__task_set_exc_guard_behavior_t Reply_task_set_exc_guard_behavior;
-	__Reply__task_create_suid_cred_t Reply_task_create_suid_cred;
+	__Reply__task_dyld_process_info_notify_register_t Reply_task_dyld_process_info_notify_register;
+	__Reply__task_create_identity_token_t Reply_task_create_identity_token;
+	__Reply__task_identity_token_get_task_port_t Reply_task_identity_token_get_task_port;
+	__Reply__task_dyld_process_info_notify_deregister_t Reply_task_dyld_process_info_notify_deregister;
+	__Reply__task_get_exception_ports_info_t Reply_task_get_exception_ports_info;
+	__Reply__task_test_sync_upcall_t Reply_task_test_sync_upcall;
+	__Reply__task_set_corpse_forking_behavior_t Reply_task_set_corpse_forking_behavior;
+	__Reply__task_test_async_upcall_propagation_t Reply_task_test_async_upcall_propagation;
+	__Reply__task_map_kcdata_object_64_t Reply_task_map_kcdata_object_64;
 };
 #endif /* !__RequestUnion__task_subsystem__defined */
 
@@ -2513,7 +2821,15 @@ union __ReplyUnion__task_subsystem {
     { "task_inspect", 3451 },\
     { "task_get_exc_guard_behavior", 3452 },\
     { "task_set_exc_guard_behavior", 3453 },\
-    { "task_create_suid_cred", 3454 }
+    { "task_dyld_process_info_notify_register", 3456 },\
+    { "task_create_identity_token", 3457 },\
+    { "task_identity_token_get_task_port", 3458 },\
+    { "task_dyld_process_info_notify_deregister", 3459 },\
+    { "task_get_exception_ports_info", 3460 },\
+    { "task_test_sync_upcall", 3461 },\
+    { "task_set_corpse_forking_behavior", 3462 },\
+    { "task_test_async_upcall_propagation", 3463 },\
+    { "task_map_kcdata_object_64", 3464 }
 #endif
 
 #ifdef __AfterMigUserHeader
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/task_policy.h b/lib/libc/include/any-macos.13-any/mach/task_policy.h
similarity index 99%
rename from lib/libc/include/x86_64-macos.10-none/mach/task_policy.h
rename to lib/libc/include/any-macos.13-any/mach/task_policy.h
index 4b6d3f9449..3e141668be 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/task_policy.h
+++ b/lib/libc/include/any-macos.13-any/mach/task_policy.h
@@ -110,8 +110,7 @@ typedef integer_t       *task_policy_t;
 #define TASK_BASE_LATENCY_QOS_POLICY    10
 #define TASK_BASE_THROUGHPUT_QOS_POLICY 11
 
-
-enum task_role {
+typedef enum task_role {
 	TASK_RENICED                    = -1,
 	TASK_UNSPECIFIED                = 0,
 	TASK_FOREGROUND_APPLICATION     = 1,
@@ -122,9 +121,7 @@ enum task_role {
 	TASK_NONUI_APPLICATION          = 6,
 	TASK_DEFAULT_APPLICATION        = 7,
 	TASK_DARWINBG_APPLICATION       = 8,
-};
-
-typedef integer_t       task_role_t;
+} task_role_t;
 
 struct task_category_policy {
 	task_role_t             role;
@@ -184,6 +181,4 @@ typedef struct task_qos_policy *task_qos_policy_t;
 #define PROC_FLAG_IOS_APPLICATION PROC_FLAG_APPLICATION /* Process is an application */
 
 
-
-
 #endif  /* _MACH_TASK_POLICY_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/thread_act.h b/lib/libc/include/any-macos.13-any/mach/thread_act.h
similarity index 89%
rename from lib/libc/include/x86_64-macos.10-none/mach/thread_act.h
rename to lib/libc/include/any-macos.13-any/mach/thread_act.h
index 88561082cd..0e6c943508 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/thread_act.h
+++ b/lib/libc/include/any-macos.13-any/mach/thread_act.h
@@ -25,7 +25,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
+#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_ATTR
+#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_COUNTEDBY_ATTR(C) __unsafe_indexable
+#endif
+	extern int mig_strncpy_zerofill(char * dest, const char * src, int len) __attribute__((weak_import));
 #ifdef __cplusplus
 }
 #endif
@@ -41,7 +44,7 @@ extern "C" {
 #define FUNCTION_PTR_T
 typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
 typedef struct {
-        char            *name;
+        char            * name;
         function_ptr_t  function;
 } function_table_entry;
 typedef function_table_entry   *function_table_t;
@@ -49,9 +52,10 @@ typedef function_table_entry   *function_table_t;
 #endif /* AUTOTEST */
 
 #ifndef	thread_act_MSG_COUNT
-#define	thread_act_MSG_COUNT	28
+#define	thread_act_MSG_COUNT	31
 #endif	/* thread_act_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>
@@ -71,8 +75,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t thread_terminate
 (
 	thread_act_t target_act
@@ -84,11 +87,10 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t act_get_state
 (
-	thread_act_t target_act,
+	thread_read_t target_act,
 	int flavor,
 	thread_state_t old_state,
 	mach_msg_type_number_t *old_stateCnt
@@ -100,8 +102,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t act_set_state
 (
 	thread_act_t target_act,
@@ -119,7 +120,7 @@ extern
 __WATCHOS_PROHIBITED
 kern_return_t thread_get_state
 (
-	thread_act_t target_act,
+	thread_read_t target_act,
 	thread_state_flavor_t flavor,
 	thread_state_t old_state,
 	mach_msg_type_number_t *old_stateCnt
@@ -149,7 +150,7 @@ extern
 __WATCHOS_PROHIBITED
 kern_return_t thread_suspend
 (
-	thread_act_t target_act
+	thread_read_t target_act
 );
 
 /* Routine thread_resume */
@@ -161,7 +162,7 @@ extern
 __WATCHOS_PROHIBITED
 kern_return_t thread_resume
 (
-	thread_act_t target_act
+	thread_read_t target_act
 );
 
 /* Routine thread_abort */
@@ -194,8 +195,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t thread_depress_abort
 (
 	thread_act_t thread
@@ -207,11 +207,10 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t thread_get_special_port
 (
-	thread_act_t thr_act,
+	thread_inspect_t thr_act,
 	int which_port,
 	mach_port_t *special_port
 );
@@ -222,8 +221,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t thread_set_special_port
 (
 	thread_act_t thr_act,
@@ -251,8 +249,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t thread_set_exception_ports
 (
 	thread_act_t thread,
@@ -268,11 +265,10 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t thread_get_exception_ports
 (
-	thread_inspect_t thread,
+	thread_act_t thread,
 	exception_mask_t exception_mask,
 	exception_mask_array_t masks,
 	mach_msg_type_number_t *masksCnt,
@@ -287,8 +283,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t thread_swap_exception_ports
 (
 	thread_act_t thread,
@@ -402,7 +397,7 @@ extern
 #endif	/* mig_external */
 kern_return_t thread_get_assignment
 (
-	thread_act_t thread,
+	thread_inspect_t thread,
 	processor_set_name_t *assigned_set
 );
 
@@ -429,11 +424,10 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t thread_get_mach_voucher
 (
-	thread_act_t thr_act,
+	thread_read_t thr_act,
 	mach_voucher_selector_t which,
 	ipc_voucher_t *voucher
 );
@@ -444,8 +438,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t thread_set_mach_voucher
 (
 	thread_act_t thr_act,
@@ -458,8 +451,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t thread_swap_mach_voucher
 (
 	thread_act_t thr_act,
@@ -467,6 +459,40 @@ kern_return_t thread_swap_mach_voucher
 	ipc_voucher_t *old_voucher
 );
 
+/* Routine thread_convert_thread_state */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t thread_convert_thread_state
+(
+	thread_act_t thread,
+	int direction,
+	thread_state_flavor_t flavor,
+	thread_state_t in_state,
+	mach_msg_type_number_t in_stateCnt,
+	thread_state_t out_state,
+	mach_msg_type_number_t *out_stateCnt
+);
+
+/* Routine thread_get_exception_ports_info */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t thread_get_exception_ports_info
+(
+	mach_port_t port,
+	exception_mask_t exception_mask,
+	exception_mask_array_t masks,
+	mach_msg_type_number_t *masksCnt,
+	exception_handler_info_array_t old_handlers_info,
+	exception_behavior_array_t old_behaviors,
+	exception_flavor_array_t old_flavors
+);
+
 __END_DECLS
 
 /********************** Caution **************************/
@@ -516,7 +542,7 @@ __END_DECLS
 		NDR_record_t NDR;
 		int flavor;
 		mach_msg_type_number_t new_stateCnt;
-		natural_t new_state[614];
+		natural_t new_state[1296];
 	} __Request__act_set_state_t __attribute__((unused));
 #ifdef  __MigPackStructs
 #pragma pack(pop)
@@ -543,7 +569,7 @@ __END_DECLS
 		NDR_record_t NDR;
 		thread_state_flavor_t flavor;
 		mach_msg_type_number_t new_stateCnt;
-		natural_t new_state[614];
+		natural_t new_state[1296];
 	} __Request__thread_set_state_t __attribute__((unused));
 #ifdef  __MigPackStructs
 #pragma pack(pop)
@@ -851,6 +877,34 @@ __END_DECLS
 #ifdef  __MigPackStructs
 #pragma pack(pop)
 #endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		int direction;
+		thread_state_flavor_t flavor;
+		mach_msg_type_number_t in_stateCnt;
+		natural_t in_state[1296];
+		mach_msg_type_number_t out_stateCnt;
+	} __Request__thread_convert_thread_state_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		exception_mask_t exception_mask;
+	} __Request__thread_get_exception_ports_info_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
 #endif /* !__Request__thread_act_subsystem__defined */
 
 /* union of all requests */
@@ -886,6 +940,8 @@ union __RequestUnion__thread_act_subsystem {
 	__Request__thread_get_mach_voucher_t Request_thread_get_mach_voucher;
 	__Request__thread_set_mach_voucher_t Request_thread_set_mach_voucher;
 	__Request__thread_swap_mach_voucher_t Request_thread_swap_mach_voucher;
+	__Request__thread_convert_thread_state_t Request_thread_convert_thread_state;
+	__Request__thread_get_exception_ports_info_t Request_thread_get_exception_ports_info;
 };
 #endif /* !__RequestUnion__thread_act_subsystem__defined */
 /* typedefs for all replies */
@@ -913,7 +969,7 @@ union __RequestUnion__thread_act_subsystem {
 		NDR_record_t NDR;
 		kern_return_t RetCode;
 		mach_msg_type_number_t old_stateCnt;
-		natural_t old_state[614];
+		natural_t old_state[1296];
 	} __Reply__act_get_state_t __attribute__((unused));
 #ifdef  __MigPackStructs
 #pragma pack(pop)
@@ -939,7 +995,7 @@ union __RequestUnion__thread_act_subsystem {
 		NDR_record_t NDR;
 		kern_return_t RetCode;
 		mach_msg_type_number_t old_stateCnt;
-		natural_t old_state[614];
+		natural_t old_state[1296];
 	} __Reply__thread_get_state_t __attribute__((unused));
 #ifdef  __MigPackStructs
 #pragma pack(pop)
@@ -1259,6 +1315,37 @@ union __RequestUnion__thread_act_subsystem {
 #ifdef  __MigPackStructs
 #pragma pack(pop)
 #endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		mach_msg_type_number_t out_stateCnt;
+		natural_t out_state[1296];
+	} __Reply__thread_convert_thread_state_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		mach_msg_type_number_t masksCnt;
+		exception_mask_t masks[32];
+		exception_handler_info_t old_handlers_info[32];
+		exception_behavior_t old_behaviors[32];
+		thread_state_flavor_t old_flavors[32];
+	} __Reply__thread_get_exception_ports_info_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
 #endif /* !__Reply__thread_act_subsystem__defined */
 
 /* union of all replies */
@@ -1294,6 +1381,8 @@ union __ReplyUnion__thread_act_subsystem {
 	__Reply__thread_get_mach_voucher_t Reply_thread_get_mach_voucher;
 	__Reply__thread_set_mach_voucher_t Reply_thread_set_mach_voucher;
 	__Reply__thread_swap_mach_voucher_t Reply_thread_swap_mach_voucher;
+	__Reply__thread_convert_thread_state_t Reply_thread_convert_thread_state;
+	__Reply__thread_get_exception_ports_info_t Reply_thread_get_exception_ports_info;
 };
 #endif /* !__RequestUnion__thread_act_subsystem__defined */
 
@@ -1326,7 +1415,9 @@ union __ReplyUnion__thread_act_subsystem {
     { "thread_set_policy", 3624 },\
     { "thread_get_mach_voucher", 3625 },\
     { "thread_set_mach_voucher", 3626 },\
-    { "thread_swap_mach_voucher", 3627 }
+    { "thread_swap_mach_voucher", 3627 },\
+    { "thread_convert_thread_state", 3628 },\
+    { "thread_get_exception_ports_info", 3630 }
 #endif
 
 #ifdef __AfterMigUserHeader
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/thread_policy.h b/lib/libc/include/any-macos.13-any/mach/thread_policy.h
similarity index 95%
rename from lib/libc/include/x86_64-macos.10-none/mach/thread_policy.h
rename to lib/libc/include/any-macos.13-any/mach/thread_policy.h
index e15504cff4..0e87792922 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/thread_policy.h
+++ b/lib/libc/include/any-macos.13-any/mach/thread_policy.h
@@ -131,7 +131,11 @@ typedef struct thread_extended_policy   *thread_extended_policy_t;
  *
  * computation: This is the nominal amount of computation
  * time needed during a separate processing arrival, specified
- * in absolute time units.
+ * in absolute time units.  The thread may be preempted after
+ * the computation time has elapsed.
+ * If (computation < constraint/2) it will be forced to
+ * constraint/2 to avoid unintended preemption and associated
+ * timer interrupts.
  *
  * constraint: This is the maximum amount of real time that
  * may elapse from the start of a separate processing arrival
@@ -139,11 +143,11 @@ typedef struct thread_extended_policy   *thread_extended_policy_t;
  * specified in absolute time units.  Must be (>= computation).
  * Note that latency = (constraint - computation).
  *
- * preemptible: This indicates that the computation may be
- * interrupted, subject to the constraint specified above.
+ * preemptible: IGNORED (This indicates that the computation may be
+ * interrupted, subject to the constraint specified above.)
  */
 
-#define THREAD_TIME_CONSTRAINT_POLICY   2
+#define THREAD_TIME_CONSTRAINT_POLICY           2
 
 struct thread_time_constraint_policy {
 	uint32_t                period;
@@ -261,6 +265,4 @@ typedef struct thread_throughput_qos_policy     *thread_throughput_qos_policy_t;
 	    (sizeof (thread_throughput_qos_policy_data_t) / sizeof (integer_t)))
 
 
-
-
 #endif  /* _MACH_THREAD_POLICY_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/vm_map.h b/lib/libc/include/any-macos.13-any/mach/vm_map.h
similarity index 93%
rename from lib/libc/include/x86_64-macos.10-none/mach/vm_map.h
rename to lib/libc/include/any-macos.13-any/mach/vm_map.h
index 59b3e7ffac..9d1f51b955 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/vm_map.h
+++ b/lib/libc/include/any-macos.13-any/mach/vm_map.h
@@ -25,7 +25,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
+#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_ATTR
+#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS_CSTRING_COUNTEDBY_ATTR(C) __unsafe_indexable
+#endif
+	extern int mig_strncpy_zerofill(char * dest, const char * src, int len) __attribute__((weak_import));
 #ifdef __cplusplus
 }
 #endif
@@ -41,7 +44,7 @@ extern "C" {
 #define FUNCTION_PTR_T
 typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
 typedef struct {
-        char            *name;
+        char            * name;
         function_ptr_t  function;
 } function_table_entry;
 typedef function_table_entry   *function_table_t;
@@ -49,9 +52,10 @@ typedef function_table_entry   *function_table_t;
 #endif /* AUTOTEST */
 
 #ifndef	vm_map_MSG_COUNT
-#define	vm_map_MSG_COUNT	32
+#define	vm_map_MSG_COUNT	33
 #endif	/* vm_map_MSG_COUNT */
 
+#include <Availability.h>
 #include <mach/std_types.h>
 #include <mach/mig.h>
 #include <mach/mig.h>
@@ -74,7 +78,7 @@ extern
 #endif	/* mig_external */
 kern_return_t vm_region
 (
-	vm_map_t target_task,
+	vm_map_read_t target_task,
 	vm_address_t *address,
 	vm_size_t *size,
 	vm_region_flavor_t flavor,
@@ -147,7 +151,7 @@ extern
 #endif	/* mig_external */
 kern_return_t vm_read
 (
-	vm_map_t target_task,
+	vm_map_read_t target_task,
 	vm_address_t address,
 	vm_size_t size,
 	vm_offset_t *data,
@@ -162,7 +166,7 @@ extern
 #endif	/* mig_external */
 kern_return_t vm_read_list
 (
-	vm_map_t target_task,
+	vm_map_read_t target_task,
 	vm_read_entry_t data_list,
 	natural_t count
 );
@@ -203,7 +207,7 @@ extern
 #endif	/* mig_external */
 kern_return_t vm_read_overwrite
 (
-	vm_map_t target_task,
+	vm_map_read_t target_task,
 	vm_address_t address,
 	vm_size_t size,
 	vm_address_t data,
@@ -301,8 +305,7 @@ mig_external
 #else
 extern
 #endif	/* mig_external */
-__WATCHOS_PROHIBITED
-__TVOS_PROHIBITED
+__TVOS_PROHIBITED __WATCHOS_PROHIBITED
 kern_return_t task_wire
 (
 	vm_map_t target_task,
@@ -333,7 +336,7 @@ extern
 #endif	/* mig_external */
 kern_return_t vm_map_page_query
 (
-	vm_map_t target_map,
+	vm_map_read_t target_map,
 	vm_offset_t offset,
 	integer_t *disposition,
 	integer_t *ref_count
@@ -347,7 +350,7 @@ extern
 #endif	/* mig_external */
 kern_return_t mach_vm_region_info
 (
-	vm_map_t task,
+	vm_map_read_t task,
 	vm_address_t address,
 	vm_info_region_t *region,
 	vm_info_object_array_t *objects,
@@ -362,7 +365,7 @@ extern
 #endif	/* mig_external */
 kern_return_t vm_mapped_pages_info
 (
-	vm_map_t task,
+	vm_map_read_t task,
 	page_address_array_t *pages,
 	mach_msg_type_number_t *pagesCnt
 );
@@ -375,7 +378,7 @@ extern
 #endif	/* mig_external */
 kern_return_t vm_region_recurse
 (
-	vm_map_t target_task,
+	vm_map_read_t target_task,
 	vm_address_t *address,
 	vm_size_t *size,
 	natural_t *nesting_depth,
@@ -391,7 +394,7 @@ extern
 #endif	/* mig_external */
 kern_return_t vm_region_recurse_64
 (
-	vm_map_t target_task,
+	vm_map_read_t target_task,
 	vm_address_t *address,
 	vm_size_t *size,
 	natural_t *nesting_depth,
@@ -407,7 +410,7 @@ extern
 #endif	/* mig_external */
 kern_return_t mach_vm_region_info_64
 (
-	vm_map_t task,
+	vm_map_read_t task,
 	vm_address_t address,
 	vm_info_region_64_t *region,
 	vm_info_object_array_t *objects,
@@ -422,7 +425,7 @@ extern
 #endif	/* mig_external */
 kern_return_t vm_region_64
 (
-	vm_map_t target_task,
+	vm_map_read_t target_task,
 	vm_address_t *address,
 	vm_size_t *size,
 	vm_region_flavor_t flavor,
@@ -493,6 +496,27 @@ kern_return_t vm_map_exec_lockdown
 	vm_map_t target_task
 );
 
+/* Routine vm_remap_new */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t vm_remap_new
+(
+	vm_map_t target_task,
+	vm_address_t *target_address,
+	vm_size_t size,
+	vm_address_t mask,
+	int flags,
+	vm_map_read_t src_task,
+	vm_address_t src_address,
+	boolean_t copy,
+	vm_prot_t *cur_protection,
+	vm_prot_t *max_protection,
+	vm_inherit_t inheritance
+);
+
 __END_DECLS
 
 /********************** Caution **************************/
@@ -924,6 +948,30 @@ __END_DECLS
 #ifdef  __MigPackStructs
 #pragma pack(pop)
 #endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t src_task;
+		/* end of the kernel processed data */
+		NDR_record_t NDR;
+		vm_address_t target_address;
+		vm_size_t size;
+		vm_address_t mask;
+		int flags;
+		vm_address_t src_address;
+		boolean_t copy;
+		vm_prot_t cur_protection;
+		vm_prot_t max_protection;
+		vm_inherit_t inheritance;
+	} __Request__vm_remap_new_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
 #endif /* !__Request__vm_map_subsystem__defined */
 
 /* union of all requests */
@@ -959,6 +1007,7 @@ union __RequestUnion__vm_map_subsystem {
 	__Request__vm_map_64_t Request_vm_map_64;
 	__Request__vm_purgable_control_t Request_vm_purgable_control;
 	__Request__vm_map_exec_lockdown_t Request_vm_map_exec_lockdown;
+	__Request__vm_remap_new_t Request_vm_remap_new;
 };
 #endif /* !__RequestUnion__vm_map_subsystem__defined */
 /* typedefs for all replies */
@@ -1363,6 +1412,21 @@ union __RequestUnion__vm_map_subsystem {
 #ifdef  __MigPackStructs
 #pragma pack(pop)
 #endif
+
+#ifdef  __MigPackStructs
+#pragma pack(push, 4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		vm_address_t target_address;
+		vm_prot_t cur_protection;
+		vm_prot_t max_protection;
+	} __Reply__vm_remap_new_t __attribute__((unused));
+#ifdef  __MigPackStructs
+#pragma pack(pop)
+#endif
 #endif /* !__Reply__vm_map_subsystem__defined */
 
 /* union of all replies */
@@ -1398,6 +1462,7 @@ union __ReplyUnion__vm_map_subsystem {
 	__Reply__vm_map_64_t Reply_vm_map_64;
 	__Reply__vm_purgable_control_t Reply_vm_purgable_control;
 	__Reply__vm_map_exec_lockdown_t Reply_vm_map_exec_lockdown;
+	__Reply__vm_remap_new_t Reply_vm_remap_new;
 };
 #endif /* !__RequestUnion__vm_map_subsystem__defined */
 
@@ -1430,7 +1495,8 @@ union __ReplyUnion__vm_map_subsystem {
     { "mach_make_memory_entry_64", 3825 },\
     { "vm_map_64", 3826 },\
     { "vm_purgable_control", 3830 },\
-    { "vm_map_exec_lockdown", 3831 }
+    { "vm_map_exec_lockdown", 3831 },\
+    { "vm_remap_new", 3832 }
 #endif
 
 #ifdef __AfterMigUserHeader
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/vm_prot.h b/lib/libc/include/any-macos.13-any/mach/vm_prot.h
similarity index 82%
rename from lib/libc/include/x86_64-macos.10-none/mach/vm_prot.h
rename to lib/libc/include/any-macos.13-any/mach/vm_prot.h
index 75812fedf6..9b455415fc 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/vm_prot.h
+++ b/lib/libc/include/any-macos.13-any/mach/vm_prot.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2021 Apple Computer, Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -96,6 +96,13 @@ typedef int             vm_prot_t;
 
 #define VM_PROT_ALL     (VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE)
 
+/*
+ *	This is an alias to VM_PROT_EXECUTE to identify callers that
+ *	want to allocate an hardware assisted Read-only/read-write
+ *	trusted path in userland.
+ */
+#define        VM_PROT_RORW_TP                 (VM_PROT_EXECUTE)
+
 /*
  *	An invalid protection value.
  *	Used only by memory_object_lock_request to indicate no change
@@ -103,7 +110,8 @@ typedef int             vm_prot_t;
  *	looks like VM_PROT_ALL and then some.
  */
 
-#define VM_PROT_NO_CHANGE       ((vm_prot_t) 0x08)
+#define VM_PROT_NO_CHANGE_LEGACY       ((vm_prot_t) 0x08)
+#define VM_PROT_NO_CHANGE              ((vm_prot_t) 0x01000000)
 
 /*
  *      When a caller finds that he cannot obtain write permission on a
@@ -149,4 +157,22 @@ typedef int             vm_prot_t;
 #define VM_PROT_STRIP_READ              ((vm_prot_t) 0x80)
 #define VM_PROT_EXECUTE_ONLY    (VM_PROT_EXECUTE|VM_PROT_STRIP_READ)
 
+
+#if defined(__x86_64__)
+/*
+ * Another invalid protection value to support specifying different
+ * execute permissions for user- and supervisor- modes.  When
+ * MBE is enabled in a VM, VM_PROT_EXECUTE is used to indicate
+ * supervisor-mode execute permission, and VM_PROT_UEXEC specifies
+ * user-mode execute permission.  Currently only used by the
+ * x86 Hypervisor kext.
+ */
+#define VM_PROT_UEXEC                   ((vm_prot_t) 0x8)     /* User-mode Execute Permission */
+
+#define VM_PROT_ALLEXEC                 (VM_PROT_EXECUTE | VM_PROT_UEXEC)
+#else
+#define VM_PROT_ALLEXEC                 (VM_PROT_EXECUTE)
+#endif /* defined(__x86_64__) */
+
+
 #endif  /* _MACH_VM_PROT_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/vm_statistics.h b/lib/libc/include/any-macos.13-any/mach/vm_statistics.h
similarity index 87%
rename from lib/libc/include/x86_64-macos.10-none/mach/vm_statistics.h
rename to lib/libc/include/any-macos.13-any/mach/vm_statistics.h
index 2bfd8136b4..172e7f3bef 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/vm_statistics.h
+++ b/lib/libc/include/any-macos.13-any/mach/vm_statistics.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2020 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -66,8 +66,12 @@
 #ifndef _MACH_VM_STATISTICS_H_
 #define _MACH_VM_STATISTICS_H_
 
-#include <mach/machine/vm_types.h>
+#include <sys/cdefs.h>
 
+__BEGIN_DECLS
+
+#include <mach/machine/vm_types.h>
+#include <mach/machine/kern_return.h>
 
 /*
  * vm_statistics
@@ -167,6 +171,8 @@ struct vm_statistics64 {
 typedef struct vm_statistics64  *vm_statistics64_t;
 typedef struct vm_statistics64  vm_statistics64_data_t;
 
+kern_return_t vm_stats(void *info, unsigned int *count);
+
 /*
  * VM_STATISTICS_TRUNCATE_TO_32_BIT
  *
@@ -225,7 +231,6 @@ typedef struct vm_purgeable_info        *vm_purgeable_info_t;
 #define VM_PAGE_QUERY_PAGE_CS_NX        0x400
 #define VM_PAGE_QUERY_PAGE_REUSABLE     0x800
 
-
 /*
  * VM allocation flags:
  *
@@ -258,24 +263,26 @@ typedef struct vm_purgeable_info        *vm_purgeable_info_t;
  *	cached so that they will be stolen first if memory runs low.
  */
 
-#define VM_FLAGS_FIXED          0x0000
-#define VM_FLAGS_ANYWHERE       0x0001
-#define VM_FLAGS_PURGABLE       0x0002
-#define VM_FLAGS_4GB_CHUNK      0x0004
-#define VM_FLAGS_RANDOM_ADDR    0x0008
-#define VM_FLAGS_NO_CACHE       0x0010
-#define VM_FLAGS_RESILIENT_CODESIGN     0x0020
-#define VM_FLAGS_RESILIENT_MEDIA        0x0040
-#define VM_FLAGS_OVERWRITE      0x4000  /* delete any existing mappings first */
+#define VM_FLAGS_FIXED                  0x00000000
+#define VM_FLAGS_ANYWHERE               0x00000001
+#define VM_FLAGS_PURGABLE               0x00000002
+#define VM_FLAGS_4GB_CHUNK              0x00000004
+#define VM_FLAGS_RANDOM_ADDR            0x00000008
+#define VM_FLAGS_NO_CACHE               0x00000010
+#define VM_FLAGS_RESILIENT_CODESIGN     0x00000020
+#define VM_FLAGS_RESILIENT_MEDIA        0x00000040
+#define VM_FLAGS_PERMANENT              0x00000080
+#define VM_FLAGS_TPRO                   0x00001000
+#define VM_FLAGS_OVERWRITE              0x00004000  /* delete any existing mappings first */
 /*
  * VM_FLAGS_SUPERPAGE_MASK
  *	3 bits that specify whether large pages should be used instead of
  *	base pages (!=0), as well as the requested page size.
  */
-#define VM_FLAGS_SUPERPAGE_MASK 0x70000 /* bits 0x10000, 0x20000, 0x40000 */
-#define VM_FLAGS_RETURN_DATA_ADDR       0x100000 /* Return address of target data, rather than base of page */
-#define VM_FLAGS_RETURN_4K_DATA_ADDR    0x800000 /* Return 4K aligned address of target data */
-#define VM_FLAGS_ALIAS_MASK     0xFF000000
+#define VM_FLAGS_SUPERPAGE_MASK         0x00070000 /* bits 0x10000, 0x20000, 0x40000 */
+#define VM_FLAGS_RETURN_DATA_ADDR       0x00100000 /* Return address of target data, rather than base of page */
+#define VM_FLAGS_RETURN_4K_DATA_ADDR    0x00800000 /* Return 4K aligned address of target data */
+#define VM_FLAGS_ALIAS_MASK             0xFF000000
 #define VM_GET_FLAGS_ALIAS(flags, alias)                        \
 	        (alias) = ((flags) & VM_FLAGS_ALIAS_MASK) >> 24
 #define VM_SET_FLAGS_ALIAS(flags, alias)                        \
@@ -289,8 +296,10 @@ typedef struct vm_purgeable_info        *vm_purgeable_info_t;
 	                         VM_FLAGS_4GB_CHUNK |           \
 	                         VM_FLAGS_RANDOM_ADDR |         \
 	                         VM_FLAGS_NO_CACHE |            \
+	                         VM_FLAGS_PERMANENT |           \
 	                         VM_FLAGS_OVERWRITE |           \
 	                         VM_FLAGS_SUPERPAGE_MASK |      \
+	                         VM_FLAGS_TPRO |                \
 	                         VM_FLAGS_ALIAS_MASK)
 #define VM_FLAGS_USER_MAP       (VM_FLAGS_USER_ALLOCATE |       \
 	                         VM_FLAGS_RETURN_4K_DATA_ADDR | \
@@ -318,7 +327,10 @@ typedef struct vm_purgeable_info        *vm_purgeable_info_t;
 
 /* Reasons for exception for virtual memory */
 enum virtual_memory_guard_exception_codes {
-	kGUARD_EXC_DEALLOC_GAP  = 1u << 0
+	kGUARD_EXC_DEALLOC_GAP  = 1u << 0,
+	kGUARD_EXC_RECLAIM_COPYIO_FAILURE = 1u << 1,
+	kGUARD_EXC_RECLAIM_INDEX_FAILURE = 1u << 2,
+	kGUARD_EXC_RECLAIM_DEALLOCATE_FAILURE = 1u << 3,
 };
 
 
@@ -333,9 +345,12 @@ enum virtual_memory_guard_exception_codes {
 #define VM_LEDGER_TAG_GRAPHICS  0x00000004
 #define VM_LEDGER_TAG_NEURAL    0x00000005
 #define VM_LEDGER_TAG_MAX       0x00000005
+#define VM_LEDGER_TAG_UNCHANGED ((int)-1)
+
 /* individual bits: */
-#define VM_LEDGER_FLAG_NO_FOOTPRINT     0x00000001
-#define VM_LEDGER_FLAGS (VM_LEDGER_FLAG_NO_FOOTPRINT)
+#define VM_LEDGER_FLAG_NO_FOOTPRINT               (1 << 0)
+#define VM_LEDGER_FLAG_NO_FOOTPRINT_FOR_DEBUG    (1 << 1)
+#define VM_LEDGER_FLAGS (VM_LEDGER_FLAG_NO_FOOTPRINT | VM_LEDGER_FLAG_NO_FOOTPRINT_FOR_DEBUG)
 
 
 #define VM_MEMORY_MALLOC 1
@@ -352,6 +367,8 @@ enum virtual_memory_guard_exception_codes {
 
 #define VM_MEMORY_MALLOC_NANO 11
 #define VM_MEMORY_MALLOC_MEDIUM 12
+#define VM_MEMORY_MALLOC_PGUARD 13  // Will be removed
+#define VM_MEMORY_MALLOC_PROB_GUARD 13
 
 #define VM_MEMORY_MACH_MSG 20
 #define VM_MEMORY_IOKIT 21
@@ -512,12 +529,38 @@ enum virtual_memory_guard_exception_codes {
 /* memory allocated by CoreMedia for global image registration of frames */
 #define VM_MEMORY_CM_REGWARP 101
 
+/* memory allocated by EmbeddedAcousticRecognition for speech decoder */
+#define VM_MEMORY_EAR_DECODER 102
+
+/* CoreUI cached image data */
+#define VM_MEMORY_COREUI_CACHED_IMAGE_DATA 103
+
+/* ColorSync is using mmap for read-only copies of ICC profile data */
+#define VM_MEMORY_COLORSYNC 104
+
+/* backtrace info for simulated crashes */
+#define VM_MEMORY_BTINFO 105
+
+/* Reserve 230-239 for Rosetta */
+#define VM_MEMORY_ROSETTA 230
+#define VM_MEMORY_ROSETTA_THREAD_CONTEXT 231
+#define VM_MEMORY_ROSETTA_INDIRECT_BRANCH_MAP 232
+#define VM_MEMORY_ROSETTA_RETURN_STACK 233
+#define VM_MEMORY_ROSETTA_EXECUTABLE_HEAP 234
+#define VM_MEMORY_ROSETTA_USER_LDT 235
+#define VM_MEMORY_ROSETTA_ARENA 236
+#define VM_MEMORY_ROSETTA_10 239
+
 /* Reserve 240-255 for application */
 #define VM_MEMORY_APPLICATION_SPECIFIC_1 240
 #define VM_MEMORY_APPLICATION_SPECIFIC_16 255
 
+#define VM_MEMORY_COUNT 256
+
 #define VM_MAKE_TAG(tag) ((tag) << 24)
 
 
 
+__END_DECLS
+
 #endif  /* _MACH_VM_STATISTICS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/vm_types.h b/lib/libc/include/any-macos.13-any/mach/vm_types.h
similarity index 82%
rename from lib/libc/include/x86_64-macos.10-none/mach/vm_types.h
rename to lib/libc/include/any-macos.13-any/mach/vm_types.h
index 18ff9ae771..e5aaa9bb93 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/vm_types.h
+++ b/lib/libc/include/any-macos.13-any/mach/vm_types.h
@@ -36,9 +36,10 @@
 #include <mach/machine/vm_types.h>
 
 #include <stdint.h>
+#include <sys/cdefs.h>
 
-typedef vm_offset_t             pointer_t;
-typedef vm_offset_t             vm_address_t;
+typedef vm_offset_t             pointer_t __kernel_ptr_semantics;
+typedef vm_offset_t             vm_address_t __kernel_ptr_semantics;
 
 /*
  * We use addr64_t for 64-bit addresses that are used on both
@@ -70,10 +71,12 @@ typedef uint32_t ppnum_t;               /* Physical page number */
 
 
 
-typedef mach_port_t             vm_map_t;
+typedef mach_port_t             vm_map_t, vm_map_read_t, vm_map_inspect_t;
 
 
 #define VM_MAP_NULL             ((vm_map_t) 0)
+#define VM_MAP_INSPECT_NULL     ((vm_map_inspect_t) 0)
+#define VM_MAP_READ_NULL        ((vm_map_read_t) 0)
 
 /*
  * Evolving definitions, likely to change.
@@ -82,6 +85,20 @@ typedef mach_port_t             vm_map_t;
 typedef uint64_t                vm_object_offset_t;
 typedef uint64_t                vm_object_size_t;
 
+/*!
+ * @typedef
+ *
+ * @brief
+ * Pair of a min/max address used to denote a memory region.
+ *
+ * @discussion
+ * @c min_address must be smaller or equal to @c max_address.
+ */
+typedef struct mach_vm_range {
+	mach_vm_offset_t        min_address;
+	mach_vm_offset_t        max_address;
+} *mach_vm_range_t;
+
 
 
 
diff --git a/lib/libc/include/x86_64-macos.10-none/mach_debug/ipc_info.h b/lib/libc/include/any-macos.13-any/mach_debug/ipc_info.h
similarity index 94%
rename from lib/libc/include/x86_64-macos.10-none/mach_debug/ipc_info.h
rename to lib/libc/include/any-macos.13-any/mach_debug/ipc_info.h
index deb07cac5e..fa4a500788 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach_debug/ipc_info.h
+++ b/lib/libc/include/any-macos.13-any/mach_debug/ipc_info.h
@@ -78,7 +78,7 @@
 typedef struct ipc_info_space {
 	natural_t iis_genno_mask;       /* generation number mask */
 	natural_t iis_table_size;       /* size of table */
-	natural_t iis_table_next;       /* next possible size of table */
+	natural_t iis_table_next;       /* next possible size of table (UNUSED) */
 	natural_t iis_tree_size;        /* size of tree (UNUSED) */
 	natural_t iis_tree_small;       /* # of small entries in tree (UNUSED) */
 	natural_t iis_tree_hash;        /* # of hashed entries in tree (UNUSED) */
@@ -87,7 +87,7 @@ typedef struct ipc_info_space {
 typedef struct ipc_info_space_basic {
 	natural_t iisb_genno_mask;      /* generation number mask */
 	natural_t iisb_table_size;      /* size of table */
-	natural_t iisb_table_next;      /* next possible size of table */
+	natural_t iisb_table_next;      /* next possible size of table (UNUSED) */
 	natural_t iisb_table_inuse;     /* number of entries in use */
 	natural_t iisb_reserved[2];     /* future expansion */
 } ipc_info_space_basic_t;
@@ -113,4 +113,11 @@ typedef struct ipc_info_tree_name {
 
 typedef ipc_info_tree_name_t *ipc_info_tree_name_array_t;
 
+typedef struct ipc_info_port {
+	natural_t iip_port_object;      /* port object identifier */
+	natural_t iip_receiver_object;  /* receiver task identifier (if any) */
+} ipc_info_port_t;
+
+typedef ipc_info_port_t *exception_handler_info_array_t;
+
 #endif  /* _MACH_DEBUG_IPC_INFO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/mach_debug/mach_debug_types.h b/lib/libc/include/any-macos.13-any/mach_debug/mach_debug_types.h
new file mode 100644
index 0000000000..599a91346d
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/mach_debug/mach_debug_types.h
@@ -0,0 +1,200 @@
+/*
+ * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+/*
+ * @OSF_COPYRIGHT@
+ */
+/*
+ * Mach Operating System
+ * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
+ * All Rights Reserved.
+ *
+ * Permission to use, copy, modify and distribute this software and its
+ * documentation is hereby granted, provided that both the copyright
+ * notice and this permission notice appear in all copies of the
+ * software, derivative works or modified versions, and any portions
+ * thereof, and that both notices appear in supporting documentation.
+ *
+ * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
+ * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ *
+ * Carnegie Mellon requests users of this software to return to
+ *
+ *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
+ *  School of Computer Science
+ *  Carnegie Mellon University
+ *  Pittsburgh PA 15213-3890
+ *
+ * any improvements or extensions that they make and grant Carnegie Mellon
+ * the rights to redistribute these changes.
+ */
+/*
+ */
+/*
+ *	Mach kernel debugging interface type declarations
+ */
+
+#ifndef _MACH_DEBUG_MACH_DEBUG_TYPES_H_
+#define _MACH_DEBUG_MACH_DEBUG_TYPES_H_
+
+#include <mach_debug/ipc_info.h>
+#include <mach_debug/vm_info.h>
+#include <mach_debug/zone_info.h>
+#include <mach_debug/page_info.h>
+#include <mach_debug/hash_info.h>
+#include <mach_debug/lockgroup_info.h>
+
+#define MACH_CORE_FILEHEADER_SIGNATURE    0x0063614d20646152ULL
+#define MACH_CORE_FILEHEADER_V2_SIGNATURE 0x63614d2073736f42ULL
+#define MACH_CORE_FILEHEADER_MAXFILES 16
+#define MACH_CORE_FILEHEADER_NAMELEN 16
+
+/* The following are defined for mach_core_fileheader_v2 */
+#define MACH_CORE_FILEHEADER_V2_FLAG_LOG_ENCRYPTED_AEA    (1ULL << 0) /* The log is encrypted using AEA */
+#define MACH_CORE_FILEHEADER_V2_FLAG_EXISTING_COREFILE_KEY_FORMAT_NIST_P256 (1ULL << 8) /* The public key is an NIST-P256 ECC key */
+#define MACH_CORE_FILEHEADER_V2_FLAG_NEXT_COREFILE_KEY_FORMAT_NIST_P256 (1ULL << 16) /* The next public key is an NIST-P256 ECC key */
+
+#define MACH_CORE_FILEHEADER_V2_FLAGS_EXISTING_COREFILE_KEY_FORMAT_MASK (0x1ULL << 8) /* A bit-mask for all supported key formats */
+#define MACH_CORE_FILEHEADER_V2_FLAGS_NEXT_COREFILE_KEY_FORMAT_MASK (0x1ULL << 16) /* A bit-mask for all supported next key formats */
+
+#define MACH_CORE_FILEHEADER_V2_FLAGS_NEXT_KEY_FORMAT_TO_KEY_FORMAT(x) (((x) >> 8) & MACH_CORE_FILEHEADER_V2_FLAGS_EXISTING_COREFILE_KEY_FORMAT_MASK)
+
+/* The following are defined for mach_core_details_v2 */
+#define MACH_CORE_DETAILS_V2_FLAG_ENCRYPTED_AEA   (1ULL << 0) /* This core is encrypted using AEA */
+#define MACH_CORE_DETAILS_V2_FLAG_COMPRESSED_ZLIB (1ULL << 8) /* This core is compressed using ZLib */
+#define MACH_CORE_DETAILS_V2_FLAG_COMPRESSED_LZ4 (1ULL << 9) /* This core is compressed using LZ4 */
+
+typedef char    symtab_name_t[32];
+
+/*
+ ***********************
+ *
+ * Mach corefile layout
+ *
+ ***********************
+ *
+ * uint64_t signature
+ * uint64_t log_offset                                 >---+
+ * uint64_t log_length                                     |
+ * mach_core_details files[MACH_CORE_FILEHEADER_MAXFILES]  |
+ *   |--> uint64_t gzip_offset                   >---+     |
+ *   |    uint64_t gzip_length                       |     |
+ *   |    char core_name[]                           |     |
+ *   |--> uint64_t gzip_offset             >---+     |     |
+ *   |    uint64_t gzip_length                 |     |     |
+ *   |    char core_name[]                     |     |     |
+ *   |--> [...]                                |     |     |
+ * [log data. Plain-text]                      |     | <---+
+ * [core #1 data. Zlib compressed]             | <---+
+ * [core #2 data. Zlib compressed]         <---+
+ * [core #x data...]
+ */
+
+struct mach_core_details {
+	uint64_t gzip_offset;
+	uint64_t gzip_length;
+	char core_name[MACH_CORE_FILEHEADER_NAMELEN];
+};
+
+struct mach_core_fileheader {
+	uint64_t signature; /* MACH_CORE_FILEHEADER_SIGNATURE */
+	uint64_t log_offset;
+	uint64_t log_length;
+	uint64_t num_files;
+	struct mach_core_details files[MACH_CORE_FILEHEADER_MAXFILES];
+};
+
+/*
+ * Mach corefile V2 headers are denoted with MACH_CORE_FILEHEADER_V2_SIGNATURE.
+ * Note that the V2 headers contain a version field that further indicates the version of the
+ * header's contents. For example, if a V2 header's 'version' field indicates version 5, then
+ * the header follows the format of the 'mach_core_fileheader_v5' structure.
+ *
+ * Further note that 'mach_core_details_' structures are not bound to the same versioning scheme
+ * as the header itself. This means that it's perfectly acceptable for a 'mach_core_fileheader_v5' header
+ * to make use of 'mach_core_details_v2'
+ *
+ **************************
+ *
+ * Mach corefile layout V2 (using a version 2 header struct as an example)
+ *
+ **************************
+ *
+ * uint64_t signature
+ * uint32_t version
+ * uint64_t flags
+ * uint64_t pub_key_offset                                                             >---+
+ * uint16_t pub_key_length                                                                 |
+ * uint64_t log_offset                                                           >---+     |
+ * uint64_t log_length                                                               |     |
+ * uint64_t num_files                                                                |     |
+ * mach_core_details_v2 files[]                                                      |     |
+ *   |--> uint64_t flags                                                             |     |
+ *   |    uint64_t offset                                                  >---+     |     |
+ *   |    uint64_t length                                                      |     |     |
+ *   |    char core_name[]                                                     |     |     |
+ *   |--> uint64_t flags                                                       |     |     |
+ *   |    uint64_t offset                                            >---+     |     |     |
+ *   |    uint64_t length                                                |     |     |     |
+ *   |    char core_name[]                                               |     |     |     |
+ *   |--> [...]                                                          |     |     |     |
+ * [public key data]                                                     |     |     | <---+
+ * [log data. Plain-text or an AEA container]                            |     | <---+
+ * [core #1 data. Zlib/LZ4 compressed. Possibly in an AEA container]     | <---+
+ * [core #2 data. Zlib/LZ4 compressed. Possibly in an AEA container] <---+
+ * [core #x data...]
+ */
+
+struct mach_core_details_v2 {
+	uint64_t flags;  /* See the MACH_CORE_DETAILS_V2_FLAG_* definitions */
+	uint64_t offset;
+	uint64_t length;
+	char core_name[MACH_CORE_FILEHEADER_NAMELEN];
+};
+
+struct mach_core_fileheader_base {
+	uint64_t signature; /* MACH_CORE_FILEHEADER_V2_SIGNATURE */
+	uint32_t version;
+};
+
+struct mach_core_fileheader_v2 {
+	uint64_t signature;       /* MACH_CORE_FILEHEADER_V2_SIGNATURE */
+	uint32_t version;         /* 2 */
+	uint64_t flags;           /* See the MACH_CORE_FILEHEADER_V2_FLAG_* definitions */
+	uint64_t pub_key_offset;  /* Offset of the public key */
+	uint16_t pub_key_length;  /* Length of the public key */
+	uint64_t log_offset;
+	uint64_t log_length;
+	uint64_t num_files;
+	struct mach_core_details_v2 files[];
+};
+
+#define KOBJECT_DESCRIPTION_LENGTH      512
+typedef char kobject_description_t[KOBJECT_DESCRIPTION_LENGTH];
+
+#endif  /* _MACH_DEBUG_MACH_DEBUG_TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/malloc/malloc.h b/lib/libc/include/any-macos.13-any/malloc/malloc.h
similarity index 92%
rename from lib/libc/include/x86_64-macos.10-none/malloc/malloc.h
rename to lib/libc/include/any-macos.13-any/malloc/malloc.h
index 0bddfda43b..41db5dbb1a 100644
--- a/lib/libc/include/x86_64-macos.10-none/malloc/malloc.h
+++ b/lib/libc/include/any-macos.13-any/malloc/malloc.h
@@ -97,6 +97,10 @@ typedef struct _malloc_zone_t {
 	 * not yet been allocated. False negatives are not allowed.
 	 */
     boolean_t (* MALLOC_ZONE_FN_PTR(claimed_address))(struct _malloc_zone_t *zone, void *ptr);
+
+    /* For zone 0 implementations: try to free ptr, promising to call find_zone_and_free
+     * if it turns out not to belong to us */
+    void 	(* MALLOC_ZONE_FN_PTR(try_free_default))(struct _malloc_zone_t *zone, void *ptr);
 } malloc_zone_t;
 
 /*********	Creation and destruction	************/
@@ -216,7 +220,7 @@ typedef void vm_range_recorder_t(task_t, void *, unsigned type, vm_range_t *, un
     /* given a task and context, "records" the specified addresses */
 
 /* Print function for the print_task() operation. */
-typedef void print_task_printer_t(const char *fmt, ...);
+typedef void print_task_printer_t(const char *fmt, ...) __printflike(1,2);
 
 typedef struct malloc_introspection_t {
 	kern_return_t (* MALLOC_INTROSPECT_FN_PTR(enumerator))(task_t task, void *, unsigned type_mask, vm_address_t zone_address, memory_reader_t reader, vm_range_recorder_t recorder); /* enumerates all the malloc pointers in use */
@@ -309,6 +313,37 @@ extern void malloc_zone_enumerate_discharged_pointers(malloc_zone_t *zone, void
 extern void malloc_zone_enumerate_discharged_pointers(malloc_zone_t *zone, void *) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
 #endif /* __BLOCKS__ */
 
+/*********  Zone version summary ************/
+// Version 0, but optional:
+//   malloc_zone_t::batch_malloc
+//   malloc_zone_t::batch_free
+// Version 5:
+//   malloc_zone_t::memalign
+// Version 6:
+//   malloc_zone_t::free_definite_size
+// Version 7:
+//   malloc_introspection_t::enable_discharge_checking
+//   malloc_introspection_t::disable_discharge_checking
+//   malloc_introspection_t::discharge
+// Version 8:
+//   malloc_zone_t::pressure_relief
+// Version 9:
+//   malloc_introspection_t::reinit_lock
+// Version 10:
+//   malloc_zone_t::claimed_address
+// Version 11:
+//   malloc_introspection_t::print_task
+// Version 12:
+//   malloc_introspection_t::task_statistics
+// Version 13:
+//   - malloc_zone_t::malloc and malloc_zone_t::calloc assume responsibility for
+//     setting errno to ENOMEM on failure
+//   - malloc_zone_t::try_free_default
+
+// These functions are optional and calling them requires two checks:
+//  * Check zone version to ensure zone struct is large enough to include the member.
+//  * Check that the function pointer is not null.
+
 __END_DECLS
 
 #endif /* _MALLOC_MALLOC_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/net/if.h b/lib/libc/include/any-macos.13-any/net/if.h
similarity index 95%
rename from lib/libc/include/x86_64-macos.10-none/net/if.h
rename to lib/libc/include/any-macos.13-any/net/if.h
index c0729f0eb8..d06305aaa0 100644
--- a/lib/libc/include/x86_64-macos.10-none/net/if.h
+++ b/lib/libc/include/any-macos.13-any/net/if.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2021 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -63,28 +63,30 @@
 #ifndef _NET_IF_H_
 #define _NET_IF_H_
 
-#include <sys/cdefs.h>
-#include <net/net_kev.h>
-
 #define IF_NAMESIZE     16
 
 #if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+#include <sys/cdefs.h>
 #include <sys/appleapiopts.h>
 #ifdef __APPLE__
 
 #include <net/if_var.h>
+#include <net/net_kev.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 
 #endif
 
+#ifndef IFNAMSIZ
+#define IFNAMSIZ        IF_NAMESIZE
+#endif
+
 struct if_clonereq {
 	int     ifcr_total;             /* total cloners (out) */
 	int     ifcr_count;             /* room for this many in user buffer */
 	char    *ifcr_buffer;           /* buffer for cloner names */
 };
 
-
 #define IFF_UP          0x1             /* interface is up */
 #define IFF_BROADCAST   0x2             /* broadcast address valid */
 #define IFF_DEBUG       0x4             /* turn on debugging */
@@ -104,7 +106,6 @@ struct if_clonereq {
 #define IFF_MULTICAST   0x8000          /* supports multicast */
 
 
-
 /*
  * Capabilities that interfaces can advertise.
  *
@@ -149,9 +150,14 @@ struct if_clonereq {
 
 #define IFQ_MAXLEN      128
 #define IFNET_SLOWHZ    1       /* granularity is 1 second */
-#define IFQ_TARGET_DELAY        (10ULL * 1000 * 1000)   /* 10 ms */
-#define IFQ_UPDATE_INTERVAL     (100ULL * 1000 * 1000)  /* 100 ms */
-
+#define IFQ_DEF_C_TARGET_DELAY        (10ULL * 1000 * 1000)   /* 10 ms */
+#define IFQ_DEF_C_UPDATE_INTERVAL     (100ULL * 1000 * 1000)  /* 100 ms */
+#define IFQ_DEF_L4S_TARGET_DELAY        (10ULL * 1000 * 1000)   /* 10 ms */
+#define IFQ_DEF_L4S_UPDATE_INTERVAL     (100ULL * 1000 * 1000)  /* 100 ms */
+#define IFQ_LL_C_TARGET_DELAY     (10ULL * 1000 * 1000)   /* 10 ms */
+#define IFQ_LL_C_UPDATE_INTERVAL  (100ULL * 1000 * 1000)  /* 100 ms */
+#define IFQ_LL_L4S_TARGET_DELAY     (10ULL * 1000 * 1000)   /* 10 ms */
+#define IFQ_LL_L4S_UPDATE_INTERVAL  (100ULL * 1000 * 1000)  /* 100 ms */
 /*
  * Message format for use in obtaining information about interfaces
  * from sysctl and the routing socket
@@ -278,16 +284,17 @@ struct ifkpi {
 
 #pragma pack()
 
+
 /*
  * Interface request structure used for socket
  * ioctl's.  All interface ioctl's must have parameter
  * definitions which begin with ifr_name.  The
  * remainder may be interface specific.
  */
+#ifdef IFREQ_OPAQUE
+struct  ifreq;
+#else
 struct  ifreq {
-#ifndef IFNAMSIZ
-#define IFNAMSIZ        IF_NAMESIZE
-#endif
 	char    ifr_name[IFNAMSIZ];             /* if name, e.g. "en0" */
 	union {
 		struct  sockaddr ifru_addr;
@@ -343,12 +350,19 @@ struct  ifreq {
 	((ifr).ifr_addr.sa_len > sizeof (struct sockaddr) ? \
 	(sizeof (struct ifreq) - sizeof (struct sockaddr) + \
 	(ifr).ifr_addr.sa_len) : sizeof (struct ifreq))
+#endif /* IFREQ_OPAQUE */
 
 struct ifaliasreq {
 	char    ifra_name[IFNAMSIZ];            /* if name, e.g. "en0" */
+#if __has_ptrcheck
+	struct  sockaddr_in ifra_addr;
+	struct  sockaddr_in ifra_broadaddr;
+	struct  sockaddr_in ifra_mask;
+#else
 	struct  sockaddr ifra_addr;
 	struct  sockaddr ifra_broadaddr;
 	struct  sockaddr ifra_mask;
+#endif /* __has_ptrcheck */
 };
 
 struct rslvmulti_req {
@@ -371,7 +385,6 @@ struct ifmediareq {
 #pragma pack()
 
 
-
 #pragma pack(4)
 struct  ifdrv {
 	char            ifd_name[IFNAMSIZ];     /* if name, e.g. "en0" */
@@ -413,7 +426,6 @@ struct  ifconf {
 #define ifc_buf ifc_ifcu.ifcu_buf       /* buffer address */
 #define ifc_req ifc_ifcu.ifcu_req       /* array of structures returned */
 
-
 /*
  * DLIL KEV_DL_PROTO_ATTACHED/DETACHED structure
  */
@@ -423,7 +435,6 @@ struct kev_dl_proto_data {
 	u_int32_t                       proto_remaining_count;
 };
 
-
 #endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
 
 struct if_nameindex {
@@ -439,4 +450,5 @@ void             if_freenameindex(struct if_nameindex *);
 __END_DECLS
 
 
+
 #endif /* !_NET_IF_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/uio.h b/lib/libc/include/any-macos.13-any/net/if_dl.h
similarity index 59%
rename from lib/libc/include/x86_64-macos.10-none/sys/uio.h
rename to lib/libc/include/any-macos.13-any/net/if_dl.h
index a5b1bad7cf..494aea0c85 100644
--- a/lib/libc/include/x86_64-macos.10-none/sys/uio.h
+++ b/lib/libc/include/any-macos.13-any/net/if_dl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2008 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2011 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -25,9 +25,8 @@
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
-/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
 /*
- * Copyright (c) 1982, 1986, 1993, 1994
+ * Copyright (c) 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -58,43 +57,72 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	@(#)uio.h	8.5 (Berkeley) 2/22/94
+ *	@(#)if_dl.h	8.1 (Berkeley) 6/10/93
+ * $FreeBSD: src/sys/net/if_dl.h,v 1.10 2000/03/01 02:46:25 archie Exp $
  */
 
-#ifndef _SYS_UIO_H_
-#define _SYS_UIO_H_
+#ifndef _NET_IF_DL_H_
+#define _NET_IF_DL_H_
+#include <sys/appleapiopts.h>
+
+#include <sys/types.h>
 
-#include <sys/cdefs.h>
-#include <sys/_types.h>
 
 /*
- * [XSI] The ssize_t and size_t types shall be defined as described
- * in <sys/types.h>.
+ * A Link-Level Sockaddr may specify the interface in one of two
+ * ways: either by means of a system-provided index number (computed
+ * anew and possibly differently on every reboot), or by a human-readable
+ * string such as "il0" (for managerial convenience).
+ *
+ * Census taking actions, such as something akin to SIOCGCONF would return
+ * both the index and the human name.
+ *
+ * High volume transactions (such as giving a link-level ``from'' address
+ * in a recvfrom or recvmsg call) may be likely only to provide the indexed
+ * form, (which requires fewer copy operations and less space).
+ *
+ * The form and interpretation  of the link-level address is purely a matter
+ * of convention between the device driver and its consumers; however, it is
+ * expected that all drivers for an interface of a given if_type will agree.
  */
-#include <sys/_types/_size_t.h>
-#include <sys/_types/_ssize_t.h>
 
 /*
- * [XSI] Structure whose address is passed as the second parameter to the
- * readv() and writev() functions.
+ * Structure of a Link-Level sockaddr:
  */
-#include <sys/_types/_iovec_t.h>
-
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/*
- * IO direction for uio_t.
- *	UIO_READ - data moves into iovec(s) associated with uio_t
- *	UIO_WRITE - data moves out of iovec(s) associated with uio_t
- */
-enum uio_rw { UIO_READ, UIO_WRITE };
+#if __has_ptrcheck
+#define DLIL_SDLDATACOUNT   __counted_by(sdl_len - 8)
+#else
+#define DLIL_SDLDATACOUNT   12
 #endif
 
+struct sockaddr_dl {
+	u_char  sdl_len;        /* Total length of sockaddr */
+	u_char  sdl_family;     /* AF_LINK */
+	u_short sdl_index;      /* if != 0, system given index for interface */
+	u_char  sdl_type;       /* interface type */
+	u_char  sdl_nlen;       /* interface name length, no trailing 0 reqd. */
+	u_char  sdl_alen;       /* link level address length */
+	u_char  sdl_slen;       /* link layer selector length */
+	char    sdl_data[DLIL_SDLDATACOUNT];
+	/* minimum work area, can be larger;
+	 *  contains both if name and ll address */
+#ifndef __APPLE__
+	/* For TokenRing */
+	u_short sdl_rcf;        /* source routing control */
+	u_short sdl_route[16];  /* source routing information */
+#endif
+};
 
+#define LLADDR(s) ((caddr_t)((s)->sdl_data + (s)->sdl_nlen))
+
+
+
+#include <sys/cdefs.h>
 
 __BEGIN_DECLS
-ssize_t readv(int, const struct iovec *, int) __DARWIN_ALIAS_C(readv);
-ssize_t writev(int, const struct iovec *, int) __DARWIN_ALIAS_C(writev);
+void    link_addr(const char *, struct sockaddr_dl *);
+char    *link_ntoa(const struct sockaddr_dl *);
 __END_DECLS
 
-#endif /* !_SYS_UIO_H_ */
\ No newline at end of file
+
+#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/net/if_var.h b/lib/libc/include/any-macos.13-any/net/if_var.h
similarity index 96%
rename from lib/libc/include/x86_64-macos.10-none/net/if_var.h
rename to lib/libc/include/any-macos.13-any/net/if_var.h
index 6dcaa3842e..32b7918282 100644
--- a/lib/libc/include/x86_64-macos.10-none/net/if_var.h
+++ b/lib/libc/include/any-macos.13-any/net/if_var.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2021 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -70,6 +70,7 @@
 #include <sys/time.h>
 #include <sys/queue.h>          /* get TAILQ macros */
 #ifdef BSD_KERN_PRIVATE
+#include <net/pktsched/pktsched.h>
 #include <sys/eventhandler.h>
 #endif
 
@@ -90,7 +91,7 @@
 #define APPLE_IF_FAM_FIREWIRE  13
 #define APPLE_IF_FAM_BOND      14
 #define APPLE_IF_FAM_CELLULAR  15
-#define APPLE_IF_FAM_6LOWPAN   16
+#define APPLE_IF_FAM_UNUSED_16 16       /* Un-used */
 #define APPLE_IF_FAM_UTUN      17
 #define APPLE_IF_FAM_IPSEC     18
 #endif /* __APPLE__ */
@@ -223,6 +224,13 @@ struct if_data64 {
 
 #pragma pack()
 
+#if defined(DRIVERKIT) || defined(PRIVATE) || defined(DRIVERKIT_PRIVATE)
+#include <net/if_var_status.h>
+#else
+struct ifnet_interface_advisory;
+#endif /* defined(DRIVERKIT) || defined(PRIVATE) || defined(DRIVERKIT_PRIVATE) */
+
+
 /*
  * Structure defining a queue for a network interface.
  */
@@ -236,7 +244,4 @@ struct  ifqueue {
 
 
 
-
-
-
 #endif /* !_NET_IF_VAR_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/net/route.h b/lib/libc/include/any-macos.13-any/net/route.h
similarity index 96%
rename from lib/libc/include/x86_64-macos.10-none/net/route.h
rename to lib/libc/include/any-macos.13-any/net/route.h
index 77ff23a3e1..968eb0c2aa 100644
--- a/lib/libc/include/x86_64-macos.10-none/net/route.h
+++ b/lib/libc/include/any-macos.13-any/net/route.h
@@ -84,7 +84,7 @@ struct rt_metrics {
 	u_int32_t       rmx_rttvar;     /* estimated rtt variance */
 	u_int32_t       rmx_pksent;     /* packets sent using this route */
 	u_int32_t       rmx_state;      /* route state */
-	u_int32_t       rmx_filler[3];  /* will be used for T/TCP later */
+	u_int32_t       rmx_filler[3];  /* will be used for TCP's peer-MSS cache */
 };
 
 /*
@@ -92,8 +92,6 @@ struct rt_metrics {
  */
 #define RTM_RTTUNIT     1000000 /* units for rtt, rttvar, as units per sec */
 
-
-
 #define RTF_UP          0x1             /* route usable */
 #define RTF_GATEWAY     0x2             /* destination is a gateway */
 #define RTF_HOST        0x4             /* host entry (net otherwise) */
@@ -127,7 +125,8 @@ struct rt_metrics {
 #define RTF_PROXY       0x8000000       /* proxying, no interface scope */
 #define RTF_ROUTER      0x10000000      /* host is a router */
 #define RTF_DEAD        0x20000000      /* Route entry is being freed */
-                                        /* 0x40000000 and up unassigned */
+#define RTF_GLOBAL      0x40000000      /* route to destination of the global internet */
+                                        /* 0x80000000 unassigned */
 
 #define RTPRF_OURS      RTF_PROTO3      /* set on routes we manage */
 #define RTF_BITS \
@@ -135,10 +134,15 @@ struct rt_metrics {
 	"\10DELCLONE\11CLONING\12XRESOLVE\13LLINFO\14STATIC\15BLACKHOLE" \
 	"\16NOIFREF\17PROTO2\20PROTO1\21PRCLONING\22WASCLONED\23PROTO3" \
 	"\25PINNED\26LOCAL\27BROADCAST\30MULTICAST\31IFSCOPE\32CONDEMNED" \
-	"\33IFREF\34PROXY\35ROUTER"
+	"\33IFREF\34PROXY\35ROUTER\37GLOBAL"
 
 #define IS_DIRECT_HOSTROUTE(rt) \
 	(((rt)->rt_flags & (RTF_HOST | RTF_GATEWAY)) == RTF_HOST)
+
+#define IS_DYNAMIC_DIRECT_HOSTROUTE(rt) \
+	(((rt)->rt_flags & (RTF_CLONING | RTF_PRCLONING | RTF_HOST | RTF_LLINFO |\
+	    RTF_WASCLONED | RTF_GATEWAY)) ==\
+	 (RTF_HOST | RTF_LLINFO | RTF_WASCLONED))
 /*
  * Routing statistics.
  */
@@ -184,7 +188,6 @@ struct rt_msghdr2 {
 	struct rt_metrics rtm_rmx; /* metrics themselves */
 };
 
-
 #define RTM_VERSION     5       /* Up the ante and ignore older versions */
 
 /*
diff --git a/lib/libc/include/x86_64-macos.10-none/netinet/in.h b/lib/libc/include/any-macos.13-any/netinet/in.h
similarity index 99%
rename from lib/libc/include/x86_64-macos.10-none/netinet/in.h
rename to lib/libc/include/any-macos.13-any/netinet/in.h
index 0e921c2965..f2daff26a4 100644
--- a/lib/libc/include/x86_64-macos.10-none/netinet/in.h
+++ b/lib/libc/include/any-macos.13-any/netinet/in.h
@@ -63,14 +63,14 @@
 
 #ifndef _NETINET_IN_H_
 #define _NETINET_IN_H_
+
 #include <sys/appleapiopts.h>
-#include <sys/_types.h>
 #include <stdint.h>             /* uint(8|16|32)_t */
 
 #include <Availability.h>
 
-#include <sys/_types/_in_addr_t.h>
 
+#include <sys/_types/_in_addr_t.h>
 #include <sys/_types/_in_port_t.h>
 
 /*
@@ -360,7 +360,6 @@ struct in_addr {
 	                 (((u_int32_t)(i) & 0xfff00000) == 0xac100000) || \
 	                 (((u_int32_t)(i) & 0xffff0000) == 0xc0a80000))
 
-
 #define IN_LOCAL_GROUP(i)       (((u_int32_t)(i) & 0xffffff00) == 0xe0000000)
 
 #define IN_ANY_LOCAL(i)         (IN_LINKLOCAL(i) || IN_LOCAL_GROUP(i))
@@ -384,7 +383,6 @@ struct sockaddr_in {
     (bcmp(&(a)->s_addr, &(b)->s_addr, \
 	sizeof (struct in_addr)) == 0)
 
-
 #define INET_ADDRSTRLEN                 16
 
 #if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
@@ -435,6 +433,7 @@ struct ip_opts {
 #define IP_PKTINFO              26   /* get pktinfo on recv socket, set src on sent dgram  */
 #define IP_RECVPKTINFO          IP_PKTINFO      /* receive pktinfo w/dgram */
 #define IP_RECVTOS              27   /* bool; receive IP TOS w/dgram */
+#define IP_DONTFRAG             28   /* don't fragment packet */
 
 #define IP_FW_ADD               40   /* add a firewall rule to chain */
 #define IP_FW_DEL               41   /* delete a firewall rule from chain */
@@ -628,7 +627,6 @@ struct in_pktinfo {
  */
 #define IPPROTO_MAXID   (IPPROTO_AH + 1)        /* don't list to IPPROTO_MAX */
 
-
 /*
  * Names for IP sysctl objects
  */
@@ -660,7 +658,6 @@ struct in_pktinfo {
 #undef __KAME_NETINET_IN_H_INCLUDED_
 
 
-
 #if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
 __BEGIN_DECLS
 int        bindresvport(int, struct sockaddr_in *);
@@ -668,4 +665,6 @@ struct sockaddr;
 int        bindresvport_sa(int, struct sockaddr *);
 __END_DECLS
 #endif
+
+
 #endif /* _NETINET_IN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/netinet/tcp.h b/lib/libc/include/any-macos.13-any/netinet/tcp.h
similarity index 96%
rename from lib/libc/include/x86_64-macos.10-none/netinet/tcp.h
rename to lib/libc/include/any-macos.13-any/netinet/tcp.h
index f089db156e..34d9097140 100644
--- a/lib/libc/include/x86_64-macos.10-none/netinet/tcp.h
+++ b/lib/libc/include/any-macos.13-any/netinet/tcp.h
@@ -63,10 +63,15 @@
 
 #ifndef _NETINET_TCP_H_
 #define _NETINET_TCP_H_
-#include <sys/types.h>
 #include <sys/appleapiopts.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+
 #include <machine/endian.h>
 #include <machine/types.h> /* __uint32_t */
+#include <netinet/in.h>
+
+#include <sys/types.h>
 
 #if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
 typedef __uint32_t tcp_seq;
@@ -101,8 +106,11 @@ struct tcphdr {
 #define TH_URG  0x20
 #define TH_ECE  0x40
 #define TH_CWR  0x80
+#define TH_AE   0x100                   /* maps into th_x2 */
 #define TH_FLAGS        (TH_FIN|TH_SYN|TH_RST|TH_ACK|TH_URG|TH_ECE|TH_CWR)
+#define TH_FLAGS_ALL    (TH_FLAGS|TH_PUSH)
 #define TH_ACCEPT       (TH_FIN|TH_SYN|TH_RST|TH_ACK)
+#define TH_ACE          (TH_AE|TH_CWR|TH_ECE)
 
 	unsigned short  th_win;         /* window */
 	unsigned short  th_sum;         /* checksum */
@@ -143,6 +151,11 @@ struct tcphdr {
 #define TCPOPT_FASTOPEN                 34
 #define TCPOLEN_FASTOPEN_REQ            2
 
+#define TCPOPT_ACCECN0                  0xAC /* AccECN Order 0 */
+#define TCPOPT_ACCECN1                  0XAE /* AccECN Order 1 */
+#define TCPOLEN_ACCECN_EMPTY            2    /* Empty option contains kind and length */
+#define TCPOLEN_ACCECN_COUNTER          3    /* Length of each AccECN counter */
+
 /* Option definitions */
 #define TCPOPT_SACK_PERMIT_HDR  \
 (TCPOPT_NOP<<24|TCPOPT_NOP<<16|TCPOPT_SACK_PERMITTED<<8|TCPOLEN_SACK_PERMITTED)
@@ -229,7 +242,6 @@ struct tcphdr {
 
 #define TCP_NOTSENT_LOWAT       0x201   /* Low water mark for TCP unsent data */
 
-
 struct tcp_connection_info {
 	u_int8_t        tcpi_state;     /* connection state */
 	u_int8_t        tcpi_snd_wscale; /* Window scale for send window */
@@ -280,4 +292,5 @@ struct tcp_connection_info {
 };
 #endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
 
+
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/netinet6/in6.h b/lib/libc/include/any-macos.13-any/netinet6/in6.h
similarity index 96%
rename from lib/libc/include/x86_64-macos.10-none/netinet6/in6.h
rename to lib/libc/include/any-macos.13-any/netinet6/in6.h
index 19899090ad..3d4f7035e3 100644
--- a/lib/libc/include/x86_64-macos.10-none/netinet6/in6.h
+++ b/lib/libc/include/any-macos.13-any/netinet6/in6.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008-2018 Apple Inc. All rights reserved.
+ * Copyright (c) 2008-2020 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -98,6 +98,7 @@
 #ifndef _NETINET6_IN6_H_
 #define _NETINET6_IN6_H_
 #include <sys/appleapiopts.h>
+
 #include <sys/_types.h>
 #include <sys/_types/_sa_family_t.h>
 
@@ -206,6 +207,7 @@ struct sockaddr_in6 {
 #define IN6ADDR_V4MAPPED_INIT \
 	{{{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
 	    0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 }}}
+#define IN6ADDR_MULTICAST_PREFIX        IN6MASK8
 #endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
 
 extern const struct in6_addr in6addr_any;
@@ -297,6 +299,16 @@ extern const struct in6_addr in6addr_linklocal_allv2routers;
  */
 #define IN6_IS_ADDR_MULTICAST(a)        ((a)->s6_addr[0] == 0xff)
 
+#define IPV6_ADDR_MC_FLAGS(a)           ((a)->s6_addr[1] & 0xf0)
+
+#define IPV6_ADDR_MC_FLAGS_TRANSIENT            0x10
+#define IPV6_ADDR_MC_FLAGS_PREFIX               0x20
+#define IPV6_ADDR_MC_FLAGS_UNICAST_BASED        (IPV6_ADDR_MC_FLAGS_TRANSIENT | IPV6_ADDR_MC_FLAGS_PREFIX)
+
+#define IN6_IS_ADDR_UNICAST_BASED_MULTICAST(a)  \
+	(IN6_IS_ADDR_MULTICAST(a) &&            \
+	(IPV6_ADDR_MC_FLAGS(a) == IPV6_ADDR_MC_FLAGS_UNICAST_BASED))
+
 /*
  * Unique Local IPv6 Unicast Addresses (per RFC 4193)
  */
@@ -311,8 +323,9 @@ extern const struct in6_addr in6addr_linklocal_allv2routers;
 #define IN6_IS_ADDR_MC_NODELOCAL(a)     \
 	(IN6_IS_ADDR_MULTICAST(a) &&    \
 	(__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_NODELOCAL))
-#define IN6_IS_ADDR_MC_LINKLOCAL(a)     \
-	(IN6_IS_ADDR_MULTICAST(a) &&    \
+#define IN6_IS_ADDR_MC_LINKLOCAL(a)                                             \
+	(IN6_IS_ADDR_MULTICAST(a) &&                                            \
+	(IPV6_ADDR_MC_FLAGS(a) != IPV6_ADDR_MC_FLAGS_UNICAST_BASED) &&          \
 	(__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_LINKLOCAL))
 #define IN6_IS_ADDR_MC_SITELOCAL(a)     \
 	(IN6_IS_ADDR_MULTICAST(a) &&    \
@@ -325,8 +338,6 @@ extern const struct in6_addr in6addr_linklocal_allv2routers;
 	(__IPV6_ADDR_MC_SCOPE(a) == __IPV6_ADDR_SCOPE_GLOBAL))
 
 
-
-
 /*
  * Options for use with [gs]etsockopt at the IPV6 level.
  * First word of comment is data type; bool is stored in int.
@@ -369,9 +380,9 @@ extern const struct in6_addr in6addr_linklocal_allv2routers;
 #define IPV6_SOCKOPT_RESERVED1  3  /* reserved for future use */
 #endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
 #define IPV6_UNICAST_HOPS       4  /* int; IP6 hops */
-#define IPV6_MULTICAST_IF       9  /* __uint8_t; set/get IP6 multicast i/f  */
-#define IPV6_MULTICAST_HOPS     10 /* __uint8_t; set/get IP6 multicast hops */
-#define IPV6_MULTICAST_LOOP     11 /* __uint8_t; set/get IP6 mcast loopback */
+#define IPV6_MULTICAST_IF       9  /* u_int; set/get IP6 multicast i/f  */
+#define IPV6_MULTICAST_HOPS     10 /* int; set/get IP6 multicast hops */
+#define IPV6_MULTICAST_LOOP     11 /* u_int; set/get IP6 mcast loopback */
 #define IPV6_JOIN_GROUP         12 /* ip6_mreq; join a group membership */
 #define IPV6_LEAVE_GROUP        13 /* ip6_mreq; leave a group membership */
 
@@ -493,7 +504,6 @@ extern const struct in6_addr in6addr_linklocal_allv2routers;
 
 #define IPV6_BOUND_IF           125 /* int; set/get bound interface */
 
-
 /* to define items, should talk with KAME guys first, for *BSD compatibility */
 
 #define IPV6_RTHDR_LOOSE        0 /* this hop need not be a neighbor. */
@@ -613,15 +623,13 @@ struct ip6_mtuinfo {
 #define IPV6CTL_MAXIFDEFROUTERS 48
 #define IPV6CTL_MAXDYNROUTES    49
 #define ICMPV6CTL_ND6_ONLINKNSRFC4861   50
+#define IPV6CTL_ULA_USETEMPADDR 51
+
 
 /* New entries should be added here from current IPV6CTL_MAXID value. */
 /* to define items, should talk with KAME guys first, for *BSD compatibility */
 #define IPV6CTL_MAXID           51
 
-
-
-
-
 __BEGIN_DECLS
 struct cmsghdr;
 
diff --git a/lib/libc/include/x86_64-macos.10-none/objc/NSObjCRuntime.h b/lib/libc/include/any-macos.13-any/objc/NSObjCRuntime.h
similarity index 94%
rename from lib/libc/include/x86_64-macos.10-none/objc/NSObjCRuntime.h
rename to lib/libc/include/any-macos.13-any/objc/NSObjCRuntime.h
index c0d01f928e..60ce1d99ca 100644
--- a/lib/libc/include/x86_64-macos.10-none/objc/NSObjCRuntime.h
+++ b/lib/libc/include/any-macos.13-any/objc/NSObjCRuntime.h
@@ -8,7 +8,7 @@
 #include <TargetConditionals.h>
 #include <objc/objc.h>
 
-#if __LP64__ || 0 || NS_BUILD_32_LIKE_64
+#if __LP64__ || NS_BUILD_32_LIKE_64
 typedef long NSInteger;
 typedef unsigned long NSUInteger;
 #else
diff --git a/lib/libc/include/x86_64-macos.10-none/objc/message.h b/lib/libc/include/any-macos.13-any/objc/message.h
similarity index 83%
rename from lib/libc/include/x86_64-macos.10-none/objc/message.h
rename to lib/libc/include/any-macos.13-any/objc/message.h
index 3c9a5e0d08..a4c17e3b95 100644
--- a/lib/libc/include/x86_64-macos.10-none/objc/message.h
+++ b/lib/libc/include/any-macos.13-any/objc/message.h
@@ -36,12 +36,8 @@ struct objc_super {
     __unsafe_unretained _Nonnull id receiver;
 
     /// Specifies the particular superclass of the instance to message. 
-#if !defined(__cplusplus)  &&  !__OBJC2__
-    /* For compatibility with old objc-runtime.h header */
-    __unsafe_unretained _Nonnull Class class;
-#else
     __unsafe_unretained _Nonnull Class super_class;
-#endif
+
     /* super_class is the first class to search */
 };
 #endif
@@ -316,73 +312,4 @@ _objc_msgForward_stret(id _Nonnull receiver, SEL _Nonnull sel, ...)
     OBJC_ARM64_UNAVAILABLE;
 #endif
 
-
-/* Variable-argument Messaging Primitives
- *
- * Use these functions to call methods with a list of arguments, such 
- * as the one passed to forward:: .
- *
- * The contents of the argument list are architecture-specific. 
- * Consult your local function call ABI documentation for details.
- * 
- * These functions must be cast to an appropriate function pointer type 
- * before being called, except for objc_msgSendv_stret() which must not 
- * be cast to a struct-returning type.
- */
-
-typedef void* marg_list;
-
-OBJC_EXPORT id _Nullable
-objc_msgSendv(id _Nullable self, SEL _Nonnull op, size_t arg_size,
-              marg_list _Nonnull arg_frame)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT void
-objc_msgSendv_stret(void * _Nonnull stretAddr, id _Nullable self,
-                    SEL _Nonnull op, size_t arg_size,
-                    marg_list _Nullable arg_frame)
-    OBJC2_UNAVAILABLE;
-/* Note that objc_msgSendv_stret() does not return a structure type, 
- * and should not be cast to do so. This is unlike objc_msgSend_stret() 
- * and objc_msgSendSuper_stret().
- */
-#if defined(__i386__)
-OBJC_EXPORT double
-objc_msgSendv_fpret(id _Nullable self, SEL _Nonnull op,
-                    unsigned arg_size, marg_list _Nullable arg_frame)
-    OBJC2_UNAVAILABLE;
-#endif
-
-
-/* The following marg_list macros are of marginal utility. They
- * are included for compatibility with the old objc-class.h header. */
-
-#if !__OBJC2__
-
-#define marg_prearg_size	0
-
-#define marg_malloc(margs, method) \
-	do { \
-		margs = (marg_list *)malloc (marg_prearg_size + ((7 + method_getSizeOfArguments(method)) & ~7)); \
-	} while (0)
-
-#define marg_free(margs) \
-	do { \
-		free(margs); \
-	} while (0)
-	
-#define marg_adjustedOffset(method, offset) \
-	(marg_prearg_size + offset)
-
-#define marg_getRef(margs, offset, type) \
-	( (type *)((char *)margs + marg_adjustedOffset(method,offset) ) )
-
-#define marg_getValue(margs, offset, type) \
-	( *marg_getRef(margs, offset, type) )
-
-#define marg_setValue(margs, offset, type, value) \
-	( marg_getValue(margs, offset, type) = (value) )
-
-#endif
-
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/objc/objc-api.h b/lib/libc/include/any-macos.13-any/objc/objc-api.h
similarity index 86%
rename from lib/libc/include/x86_64-macos.10-none/objc/objc-api.h
rename to lib/libc/include/any-macos.13-any/objc/objc-api.h
index 504fee6113..493cc7f89a 100644
--- a/lib/libc/include/x86_64-macos.10-none/objc/objc-api.h
+++ b/lib/libc/include/any-macos.13-any/objc/objc-api.h
@@ -28,6 +28,7 @@
 #include <Availability.h>
 #include <AvailabilityMacros.h>
 #include <TargetConditionals.h>
+#include <stddef.h>
 #include <sys/types.h>
 
 #ifndef __has_feature
@@ -96,6 +97,12 @@
 #   define NS_ENFORCE_NSOBJECT_DESIGNATED_INITIALIZER 1
 #endif
 
+/* The arm64 ABI requires proper casting to ensure arguments are passed
+ *  * correctly.  */
+#if defined(__arm64__) && !__swift__
+#   undef OBJC_OLD_DISPATCH_PROTOTYPES
+#   define OBJC_OLD_DISPATCH_PROTOTYPES 0
+#endif
 
 /* OBJC_OLD_DISPATCH_PROTOTYPES == 0 enforces the rule that the dispatch 
  * functions must be cast to an appropriate function pointer type. */
@@ -147,25 +154,7 @@
 /* OBJC_ISA_AVAILABILITY: `isa` will be deprecated or unavailable 
  * in the future */
 #if !defined(OBJC_ISA_AVAILABILITY)
-#   if __OBJC2__
-#       define OBJC_ISA_AVAILABILITY  __attribute__((deprecated))
-#   else
-#       define OBJC_ISA_AVAILABILITY  /* still available */
-#   endif
-#endif
-
-
-/* OBJC2_UNAVAILABLE: unavailable in objc 2.0, deprecated in Leopard */
-#if !defined(OBJC2_UNAVAILABLE)
-#   if __OBJC2__
-#       define OBJC2_UNAVAILABLE UNAVAILABLE_ATTRIBUTE
-#   else
-        /* plain C code also falls here, but this is close enough */
-#       define OBJC2_UNAVAILABLE                                       \
-            __OSX_DEPRECATED(10.5, 10.5, "not available in __OBJC2__") \
-            __IOS_DEPRECATED(2.0, 2.0, "not available in __OBJC2__")   \
-            __TVOS_UNAVAILABLE __WATCHOS_UNAVAILABLE 
-#   endif
+#   define OBJC_ISA_AVAILABILITY  __attribute__((deprecated))
 #endif
 
 /* OBJC_UNAVAILABLE: unavailable, with a message where supported */
@@ -227,9 +216,7 @@
 #endif
 
 #if !defined(OBJC_VISIBLE)
-
 #       define OBJC_VISIBLE  __attribute__((visibility("default")))
-
 #endif
 
 #if !defined(OBJC_EXPORT)
@@ -277,4 +264,41 @@
 #   endif
 #endif
 
+/* OBJC_COLD: very rarely called, e.g. on error path */
+#if !defined(OBJC_COLD)
+#   if __OBJC__ && __has_attribute(cold)
+#       define OBJC_COLD __attribute__((cold))
+#   else
+#       define OBJC_COLD
+#   endif
+#endif
+
+/* OBJC_NORETURN: does not return normally, but may throw */
+#if !defined(OBJC_NORETURN)
+#   if __OBJC__ && __has_attribute(noreturn)
+#       define OBJC_NORETURN __attribute__((noreturn))
+#   else
+#       define OBJC_NORETURN
+#   endif
+#endif
+
+/* OBJC_NOESCAPE: marks a block as nonescaping */
+#if !defined(OBJC_NOESCAPE)
+#   if __has_attribute(noescape)
+#       define OBJC_NOESCAPE __attribute__((noescape))
+#   else
+#       define OBJC_NOESCAPE
+#   endif
+#endif
+
+/* OBJC_REFINED_FOR_SWIFT: hide the definition from Swift as we have a
+   better one in the overlay */
+#if !defined(OBJC_REFINED_FOR_SWIFT)
+#   if __has_attribute(swift_private)
+#       define OBJC_REFINED_FOR_SWIFT __attribute__((swift_private))
+#   else
+#       define OBJC_REFINED_FOR_SWIFT
+#   endif
+#endif
+
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/objc/objc.h b/lib/libc/include/any-macos.13-any/objc/objc.h
new file mode 100644
index 0000000000..fa90236f63
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/objc/objc.h
@@ -0,0 +1,236 @@
+/*
+ * Copyright (c) 1999-2007 Apple Inc.  All Rights Reserved.
+ * 
+ * @APPLE_LICENSE_HEADER_START@
+ * 
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ * 
+ * @APPLE_LICENSE_HEADER_END@
+ */
+/*
+ *	objc.h
+ *	Copyright 1988-1996, NeXT Software, Inc.
+ */
+
+#ifndef _OBJC_OBJC_H_
+#define _OBJC_OBJC_H_
+
+#include <stdlib.h>
+#include <Availability.h>
+#include <objc/objc-api.h>
+#include <stdbool.h>
+
+#if !OBJC_TYPES_DEFINED
+/// An opaque type that represents an Objective-C class.
+typedef struct objc_class *Class;
+
+/// Represents an instance of a class.
+struct objc_object {
+    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;
+};
+
+/// A pointer to an instance of a class.
+typedef struct objc_object *id;
+#endif
+
+/// An opaque type that represents a method selector.
+typedef struct objc_selector *SEL;
+
+/// A pointer to the function of a method implementation. 
+#if !OBJC_OLD_DISPATCH_PROTOTYPES
+typedef void (*IMP)(void /* id, SEL, ... */ ); 
+#else
+typedef id _Nullable (*IMP)(id _Nonnull, SEL _Nonnull, ...); 
+#endif
+
+/// Type to represent a boolean value.
+
+#if defined(__OBJC_BOOL_IS_BOOL)
+    // Honor __OBJC_BOOL_IS_BOOL when available.
+#   if __OBJC_BOOL_IS_BOOL
+#       define OBJC_BOOL_IS_BOOL 1
+#   else
+#       define OBJC_BOOL_IS_BOOL 0
+#   endif
+#else
+    // __OBJC_BOOL_IS_BOOL not set.
+#   if TARGET_OS_OSX || TARGET_OS_MACCATALYST || ((TARGET_OS_IOS || 0) && !__LP64__ && !__ARM_ARCH_7K)
+#      define OBJC_BOOL_IS_BOOL 0
+#   else
+#      define OBJC_BOOL_IS_BOOL 1
+#   endif
+#endif
+
+#if OBJC_BOOL_IS_BOOL
+    typedef bool BOOL;
+#else
+#   define OBJC_BOOL_IS_CHAR 1
+    typedef signed char BOOL; 
+    // BOOL is explicitly signed so @encode(BOOL) == "c" rather than "C" 
+    // even if -funsigned-char is used.
+#endif
+
+#define OBJC_BOOL_DEFINED
+
+#if __has_feature(objc_bool)
+#define YES __objc_yes
+#define NO  __objc_no
+#else
+#define YES ((BOOL)1)
+#define NO  ((BOOL)0)
+#endif
+
+#ifndef Nil
+# if __has_feature(cxx_nullptr)
+#   define Nil nullptr
+# else
+#   define Nil __DARWIN_NULL
+# endif
+#endif
+
+#ifndef nil
+# if __has_feature(cxx_nullptr)
+#   define nil nullptr
+# else
+#   define nil __DARWIN_NULL
+# endif
+#endif
+
+#ifndef __strong
+# if !__has_feature(objc_arc)
+#   define __strong /* empty */
+# endif
+#endif
+
+#ifndef __unsafe_unretained
+# if !__has_feature(objc_arc)
+#   define __unsafe_unretained /* empty */
+# endif
+#endif
+
+#ifndef __autoreleasing
+# if !__has_feature(objc_arc)
+#   define __autoreleasing /* empty */
+# endif
+#endif
+
+/// Forward declaration for zone support
+typedef struct _malloc_zone_t *objc_zone_t;
+
+/** 
+ * Returns the name of the method specified by a given selector.
+ * 
+ * @param sel A pointer of type \c SEL. Pass the selector whose name you wish to determine.
+ * 
+ * @return A C string indicating the name of the selector.
+ */
+OBJC_EXPORT const char * _Nonnull sel_getName(SEL _Nonnull sel)
+    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
+
+/** 
+ * Registers a method with the Objective-C runtime system, maps the method 
+ * name to a selector, and returns the selector value.
+ * 
+ * @param str A pointer to a C string. Pass the name of the method you wish to register.
+ * 
+ * @return A pointer of type SEL specifying the selector for the named method.
+ * 
+ * @note You must register a method name with the Objective-C runtime system to obtain the
+ *  method’s selector before you can add the method to a class definition. If the method name
+ *  has already been registered, this function simply returns the selector.
+ */
+OBJC_EXPORT SEL _Nonnull sel_registerName(const char * _Nonnull str)
+    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
+
+/** 
+ * Returns the class name of a given object.
+ * 
+ * @param obj An Objective-C object.
+ * 
+ * @return The name of the class of which \e obj is an instance.
+ */
+OBJC_EXPORT const char * _Nonnull object_getClassName(id _Nullable obj)
+    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
+
+/** 
+ * Returns a pointer to any extra bytes allocated with an instance given object.
+ * 
+ * @param obj An Objective-C object.
+ * 
+ * @return A pointer to any extra bytes allocated with \e obj. If \e obj was
+ *   not allocated with any extra bytes, then dereferencing the returned pointer is undefined.
+ * 
+ * @note This function returns a pointer to any extra bytes allocated with the instance
+ *  (as specified by \c class_createInstance with extraBytes>0). This memory follows the
+ *  object's ordinary ivars, but may not be adjacent to the last ivar.
+ * @note The returned pointer is guaranteed to be pointer-size aligned, even if the area following
+ *  the object's last ivar is less aligned than that. Alignment greater than pointer-size is never
+ *  guaranteed, even if the area following the object's last ivar is more aligned than that.
+ * @note In a garbage-collected environment, the memory is scanned conservatively.
+ */
+OBJC_EXPORT void * _Nullable object_getIndexedIvars(id _Nullable obj)
+    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
+
+/** 
+ * Identifies a selector as being valid or invalid.
+ * 
+ * @param sel The selector you want to identify.
+ * 
+ * @return YES if selector is valid and has a function implementation, NO otherwise. 
+ * 
+ * @warning On some platforms, an invalid reference (to invalid memory addresses) can cause
+ *  a crash. 
+ */
+OBJC_EXPORT BOOL sel_isMapped(SEL _Nonnull sel)
+    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
+
+/** 
+ * Registers a method name with the Objective-C runtime system.
+ * 
+ * @param str A pointer to a C string. Pass the name of the method you wish to register.
+ * 
+ * @return A pointer of type SEL specifying the selector for the named method.
+ * 
+ * @note The implementation of this method is identical to the implementation of \c sel_registerName.
+ * @note Prior to OS X version 10.0, this method tried to find the selector mapped to the given name
+ *  and returned \c NULL if the selector was not found. This was changed for safety, because it was
+ *  observed that many of the callers of this function did not check the return value for \c NULL.
+ */
+OBJC_EXPORT SEL _Nonnull sel_getUid(const char * _Nonnull str)
+    OBJC_AVAILABLE(10.0, 2.0, 9.0, 1.0, 2.0);
+
+typedef const void* objc_objectptr_t;
+
+
+// Obsolete ARC conversions.
+
+OBJC_EXPORT id _Nullable objc_retainedObject(objc_objectptr_t _Nullable obj)
+#if !OBJC_DECLARE_SYMBOLS
+    OBJC_UNAVAILABLE("use CFBridgingRelease() or a (__bridge_transfer id) cast instead")
+#endif
+    ;
+OBJC_EXPORT id _Nullable objc_unretainedObject(objc_objectptr_t _Nullable obj)
+#if !OBJC_DECLARE_SYMBOLS
+    OBJC_UNAVAILABLE("use a (__bridge id) cast instead")
+#endif
+    ;
+OBJC_EXPORT objc_objectptr_t _Nullable objc_unretainedPointer(id _Nullable obj)
+#if !OBJC_DECLARE_SYMBOLS
+    OBJC_UNAVAILABLE("use a __bridge cast instead")
+#endif
+    ;
+
+#endif  /* _OBJC_OBJC_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/objc/runtime.h b/lib/libc/include/any-macos.13-any/objc/runtime.h
similarity index 85%
rename from lib/libc/include/x86_64-macos.10-none/objc/runtime.h
rename to lib/libc/include/any-macos.13-any/objc/runtime.h
index 0b49b72559..5d8cf96e06 100644
--- a/lib/libc/include/x86_64-macos.10-none/objc/runtime.h
+++ b/lib/libc/include/any-macos.13-any/objc/runtime.h
@@ -32,7 +32,7 @@
 #include <TargetConditionals.h>
 
 #if TARGET_OS_MAC
-#include <sys/types.h>
+#include <stdlib.h>
 #endif
 
 
@@ -52,24 +52,6 @@ typedef struct objc_category *Category;
 /// An opaque type that represents an Objective-C declared property.
 typedef struct objc_property *objc_property_t;
 
-struct objc_class {
-    Class _Nonnull isa  OBJC_ISA_AVAILABILITY;
-
-#if !__OBJC2__
-    Class _Nullable super_class                              OBJC2_UNAVAILABLE;
-    const char * _Nonnull name                               OBJC2_UNAVAILABLE;
-    long version                                             OBJC2_UNAVAILABLE;
-    long info                                                OBJC2_UNAVAILABLE;
-    long instance_size                                       OBJC2_UNAVAILABLE;
-    struct objc_ivar_list * _Nullable ivars                  OBJC2_UNAVAILABLE;
-    struct objc_method_list * _Nullable * _Nullable methodLists                    OBJC2_UNAVAILABLE;
-    struct objc_cache * _Nonnull cache                       OBJC2_UNAVAILABLE;
-    struct objc_protocol_list * _Nullable protocols          OBJC2_UNAVAILABLE;
-#endif
-
-} OBJC2_UNAVAILABLE;
-/* Use `Class` instead of `struct objc_class *` */
-
 #endif
 
 #ifdef __OBJC__
@@ -277,13 +259,8 @@ object_getInstanceVariable(id _Nullable obj, const char * _Nonnull name,
  * @return The Class object for the named class, or \c nil
  *  if the class is not registered with the Objective-C runtime.
  * 
- * @note \c objc_getClass is different from \c objc_lookUpClass in that if the class
- *  is not registered, \c objc_getClass calls the class handler callback and then checks
- *  a second time to see whether the class is registered. \c objc_lookUpClass does 
- *  not call the class handler callback.
- * 
- * @warning Earlier implementations of this function (prior to OS X v10.0)
- *  terminate the program if the class does not exist.
+ * @note The implementation of \c objc_getClass is identical to the implementation
+ *  of \c objc_lookUpClass.
  */
 OBJC_EXPORT Class _Nullable
 objc_getClass(const char * _Nonnull name)
@@ -314,9 +291,8 @@ objc_getMetaClass(const char * _Nonnull name)
  * @return The Class object for the named class, or \c nil if the class
  *  is not registered with the Objective-C runtime.
  * 
- * @note \c objc_getClass is different from this function in that if the class is not
- *  registered, \c objc_getClass calls the class handler callback and then checks a second
- *  time to see whether the class is registered. This function does not call the class handler callback.
+ * @note The implementation of \c objc_lookUpClass is identical to the implementation
+ *  of \c objc_getClass.
  */
 OBJC_EXPORT Class _Nullable
 objc_lookUpClass(const char * _Nonnull name)
@@ -330,7 +306,6 @@ objc_lookUpClass(const char * _Nonnull name)
  * @return The Class object for the named class.
  * 
  * @note This function is the same as \c objc_getClass, but kills the process if the class is not found.
- * @note This function is used by ZeroLink, where failing to find a class would be a compile-time link error without ZeroLink.
  */
 OBJC_EXPORT Class _Nonnull
 objc_getRequiredClass(const char * _Nonnull name)
@@ -373,6 +348,32 @@ OBJC_EXPORT Class _Nonnull * _Nullable
 objc_copyClassList(unsigned int * _Nullable outCount)
     OBJC_AVAILABLE(10.7, 3.1, 9.0, 1.0, 2.0);
 
+/**
+ * Enumerates classes, filtering by image, name, protocol conformance and superclass.
+ *
+ * @param image The image to search.  Can be NULL (search the caller's image),
+ *              OBJC_DYNAMIC_CLASSES (search dynamically registered classes),
+ *              a handle returned by dlopen(3), or the Mach header of an image
+ *              loaded into the current process.
+ * @param namePrefix If non-NULL, a required prefix for the class name.
+ * @param conformingTo If non-NULL, a protocol to which the enumerated classes
+ *                     must conform.
+ * @param subclassing If non-NULL, a class which the enumerated classes must
+ *                    subclass.
+ * @param block A block that is called for each matching class.  Can abort
+ *              enumeration by setting *stop to YES.
+ *
+ */
+#define OBJC_DYNAMIC_CLASSES ((const void *)-1)
+OBJC_EXPORT void
+objc_enumerateClasses(const void * _Nullable image,
+                      const char * _Nullable namePrefix,
+                      Protocol * _Nullable conformingTo,
+                      Class _Nullable subclassing,
+                      void (^ _Nonnull block)(Class _Nonnull aClass, BOOL * _Nonnull stop)
+                      OBJC_NOESCAPE)
+    OBJC_AVAILABLE(13.0, 16.0, 16.0, 9.0, 7.0)
+    OBJC_REFINED_FOR_SWIFT;
 
 /* Working with Classes */
 
@@ -1063,7 +1064,7 @@ method_getDescription(Method _Nonnull m)
  * Sets the implementation of a method.
  * 
  * @param m The method for which to set an implementation.
- * @param imp The implemention to set to this method.
+ * @param imp The implementation to set to this method.
  * 
  * @return The previous implementation of the method.
  */
@@ -1556,6 +1557,8 @@ OBJC_EXPORT void
 objc_setForwardHandler(void * _Nonnull fwd, void * _Nonnull fwd_stret) 
     OBJC_AVAILABLE(10.5, 2.0, 9.0, 1.0, 2.0);
 
+#if !0
+
 /** 
  * Creates a pointer to a function that will call the block
  * when the method is called.
@@ -1598,6 +1601,8 @@ OBJC_EXPORT BOOL
 imp_removeBlock(IMP _Nonnull anImp)
     OBJC_AVAILABLE(10.7, 4.3, 9.0, 1.0, 2.0);
 
+#endif 
+
 /** 
  * This loads the object referenced by a weak pointer and returns it, after
  * retaining and autoreleasing the object to ensure that it stays alive
@@ -1765,43 +1770,6 @@ OBJC_EXPORT void objc_setHook_getClass(objc_hook_getClass _Nonnull newValue,
     OBJC_AVAILABLE(10.14.4, 12.2, 12.2, 5.2, 3.2);
 #endif
 
-/**
- * Function type for a hook that assists objc_setAssociatedObject().
- *
- * @param object The source object for the association.
- * @param key The key for the association.
- * @param value The value to associate with the key key for object. Pass nil to clear an existing association.
- * @param policy The policy for the association. For possible values, see “Associative Object Behaviors.”
- *
- * @see objc_setAssociatedObject
- * @see objc_setHook_setAssociatedObject
- */
-typedef void (*objc_hook_setAssociatedObject)(id _Nonnull object, const void * _Nonnull key,
-                                              id _Nullable value, objc_AssociationPolicy policy);
-
-/**
- * Install a hook for objc_setAssociatedObject().
- *
- * @param newValue The hook function to install.
- * @param outOldValue The address of a function pointer variable. On return,
- *  the old hook function is stored in the variable.
- *
- * @note The store to *outOldValue is thread-safe: the variable will be
- *  updated before objc_setAssociatedObject() calls your new hook to read it,
- *  even if your new hook is called from another thread before this
- *  setter completes.
- * @note Your hook should always call the previous hook.
- *
- * @see objc_setAssociatedObject
- * @see objc_hook_setAssociatedObject
- */
-#if !(TARGET_OS_OSX && __i386__)
-#define OBJC_SETASSOCIATEDOBJECTHOOK_DEFINED 1
-OBJC_EXPORT void objc_setHook_setAssociatedObject(objc_hook_setAssociatedObject _Nonnull newValue,
-                                       objc_hook_setAssociatedObject _Nullable * _Nonnull outOldValue)
-    OBJC_AVAILABLE(10.15, 13.0, 13.0, 6.0, 4.0);
-#endif
-
 /**
  * Function type for a function that is called when an image is loaded.
  *
@@ -1829,7 +1797,39 @@ typedef void (*objc_func_loadImage)(const struct mach_header * _Nonnull header);
 OBJC_EXPORT void objc_addLoadImageFunc(objc_func_loadImage _Nonnull func)
     OBJC_AVAILABLE(10.15, 13.0, 13.0, 6.0, 4.0);
 
-/** 
+/**
+ * Function type for a hook that provides a name for lazily named classes.
+ *
+ * @param cls The class to generate a name for.
+ * @return The name of the class, or NULL if the name isn't known or can't me generated.
+ *
+ * @see objc_setHook_lazyClassNamer
+ */
+typedef const char * _Nullable (*objc_hook_lazyClassNamer)(_Nonnull Class cls);
+
+/**
+ * Install a hook to provide a name for lazily-named classes.
+ *
+ * @param newValue The hook function to install.
+ * @param outOldValue The address of a function pointer variable. On return,
+ *  the old hook function is stored in the variable.
+ *
+ * @note The store to *outOldValue is thread-safe: the variable will be
+ *  updated before objc_getClass() calls your new hook to read it,
+ *  even if your new hook is called from another thread before this
+ *  setter completes.
+ * @note Your hook must call the previous hook for class names
+ *  that you do not recognize.
+ */
+#if !(TARGET_OS_OSX && __i386__)
+#define OBJC_SETHOOK_LAZYCLASSNAMER_DEFINED 1
+OBJC_EXPORT
+void objc_setHook_lazyClassNamer(_Nonnull objc_hook_lazyClassNamer newValue,
+                                  _Nonnull objc_hook_lazyClassNamer * _Nonnull oldOutValue)
+    OBJC_AVAILABLE(11.0, 14.0, 14.0, 7.0, 5.0);
+#endif
+
+/**
  * Callback from Objective-C to Swift to perform Swift class initialization.
  */
 #if !(TARGET_OS_OSX && __i386__)
@@ -1850,188 +1850,58 @@ _objc_realizeClassFromSwift(Class _Nullable cls, void * _Nullable previously)
     OBJC_AVAILABLE(10.14.4, 12.2, 12.2, 5.2, 3.2);
 #endif
 
+// Type encoding characters
+#define _C_ID          '@'
+#define _C_CLASS       '#'
+#define _C_SEL         ':'
+#define _C_CHR         'c'
+#define _C_UCHR        'C'
+#define _C_SHT         's'
+#define _C_USHT        'S'
+#define _C_INT         'i'
+#define _C_UINT        'I'
+#define _C_LNG         'l'
+#define _C_ULNG        'L'
+#define _C_LNG_LNG     'q'
+#define _C_ULNG_LNG    'Q'
+#define _C_INT128      't'
+#define _C_UINT128     'T'
+#define _C_FLT         'f'
+#define _C_DBL         'd'
+#define _C_LNG_DBL     'D'
+#define _C_BFLD        'b'
+#define _C_BOOL        'B'
+#define _C_VOID        'v'
+#define _C_UNDEF       '?'
+#define _C_PTR         '^'
+#define _C_CHARPTR     '*'
+#define _C_ATOM        '%'
+#define _C_ARY_B       '['
+#define _C_ARY_E       ']'
+#define _C_UNION_B     '('
+#define _C_UNION_E     ')'
+#define _C_STRUCT_B    '{'
+#define _C_STRUCT_E    '}'
+#define _C_VECTOR      '!'
 
-#define _C_ID       '@'
-#define _C_CLASS    '#'
-#define _C_SEL      ':'
-#define _C_CHR      'c'
-#define _C_UCHR     'C'
-#define _C_SHT      's'
-#define _C_USHT     'S'
-#define _C_INT      'i'
-#define _C_UINT     'I'
-#define _C_LNG      'l'
-#define _C_ULNG     'L'
-#define _C_LNG_LNG  'q'
-#define _C_ULNG_LNG 'Q'
-#define _C_FLT      'f'
-#define _C_DBL      'd'
-#define _C_BFLD     'b'
-#define _C_BOOL     'B'
-#define _C_VOID     'v'
-#define _C_UNDEF    '?'
-#define _C_PTR      '^'
-#define _C_CHARPTR  '*'
-#define _C_ATOM     '%'
-#define _C_ARY_B    '['
-#define _C_ARY_E    ']'
-#define _C_UNION_B  '('
-#define _C_UNION_E  ')'
-#define _C_STRUCT_B '{'
-#define _C_STRUCT_E '}'
-#define _C_VECTOR   '!'
-#define _C_CONST    'r'
-
-
-/* Obsolete types */
-
-#if !__OBJC2__
-
-#define CLS_GETINFO(cls,infomask)        ((cls)->info & (infomask))
-#define CLS_SETINFO(cls,infomask)        ((cls)->info |= (infomask))
-
-// class is not a metaclass
-#define CLS_CLASS               0x1
-// class is a metaclass
-#define CLS_META                0x2
-// class's +initialize method has completed
-#define CLS_INITIALIZED         0x4
-// class is posing
-#define CLS_POSING              0x8
-// unused
-#define CLS_MAPPED              0x10
-// class and subclasses need cache flush during image loading
-#define CLS_FLUSH_CACHE         0x20
-// method cache should grow when full
-#define CLS_GROW_CACHE          0x40
-// unused
-#define CLS_NEED_BIND           0x80
-// methodLists is array of method lists
-#define CLS_METHOD_ARRAY        0x100
-// the JavaBridge constructs classes with these markers
-#define CLS_JAVA_HYBRID         0x200
-#define CLS_JAVA_CLASS          0x400
-// thread-safe +initialize
-#define CLS_INITIALIZING        0x800
-// bundle unloading
-#define CLS_FROM_BUNDLE         0x1000
-// C++ ivar support
-#define CLS_HAS_CXX_STRUCTORS   0x2000
-// Lazy method list arrays
-#define CLS_NO_METHOD_ARRAY     0x4000
-// +load implementation
-#define CLS_HAS_LOAD_METHOD     0x8000
-// objc_allocateClassPair API
-#define CLS_CONSTRUCTING        0x10000
-// class compiled with bigger class structure
-#define CLS_EXT                 0x20000
-
-
-struct objc_method_description_list {
-    int count;
-    struct objc_method_description list[1];
-};
-
-
-struct objc_protocol_list {
-    struct objc_protocol_list * _Nullable next;
-    long count;
-    __unsafe_unretained Protocol * _Nullable list[1];
-};
-
-
-struct objc_category {
-    char * _Nonnull category_name                            OBJC2_UNAVAILABLE;
-    char * _Nonnull class_name                               OBJC2_UNAVAILABLE;
-    struct objc_method_list * _Nullable instance_methods     OBJC2_UNAVAILABLE;
-    struct objc_method_list * _Nullable class_methods        OBJC2_UNAVAILABLE;
-    struct objc_protocol_list * _Nullable protocols          OBJC2_UNAVAILABLE;
-}                                                            OBJC2_UNAVAILABLE;
-
-
-struct objc_ivar {
-    char * _Nullable ivar_name                               OBJC2_UNAVAILABLE;
-    char * _Nullable ivar_type                               OBJC2_UNAVAILABLE;
-    int ivar_offset                                          OBJC2_UNAVAILABLE;
-#ifdef __LP64__
-    int space                                                OBJC2_UNAVAILABLE;
-#endif
-}                                                            OBJC2_UNAVAILABLE;
-
-struct objc_ivar_list {
-    int ivar_count                                           OBJC2_UNAVAILABLE;
-#ifdef __LP64__
-    int space                                                OBJC2_UNAVAILABLE;
-#endif
-    /* variable length structure */
-    struct objc_ivar ivar_list[1]                            OBJC2_UNAVAILABLE;
-}                                                            OBJC2_UNAVAILABLE;
-
-
-struct objc_method {
-    SEL _Nonnull method_name                                 OBJC2_UNAVAILABLE;
-    char * _Nullable method_types                            OBJC2_UNAVAILABLE;
-    IMP _Nonnull method_imp                                  OBJC2_UNAVAILABLE;
-}                                                            OBJC2_UNAVAILABLE;
-
-struct objc_method_list {
-    struct objc_method_list * _Nullable obsolete             OBJC2_UNAVAILABLE;
-
-    int method_count                                         OBJC2_UNAVAILABLE;
-#ifdef __LP64__
-    int space                                                OBJC2_UNAVAILABLE;
-#endif
-    /* variable length structure */
-    struct objc_method method_list[1]                        OBJC2_UNAVAILABLE;
-}                                                            OBJC2_UNAVAILABLE;
-
-
-typedef struct objc_symtab *Symtab                           OBJC2_UNAVAILABLE;
-
-struct objc_symtab {
-    unsigned long sel_ref_cnt                                OBJC2_UNAVAILABLE;
-    SEL _Nonnull * _Nullable refs                            OBJC2_UNAVAILABLE;
-    unsigned short cls_def_cnt                               OBJC2_UNAVAILABLE;
-    unsigned short cat_def_cnt                               OBJC2_UNAVAILABLE;
-    void * _Nullable defs[1] /* variable size */             OBJC2_UNAVAILABLE;
-}                                                            OBJC2_UNAVAILABLE;
-
-
-typedef struct objc_cache *Cache                             OBJC2_UNAVAILABLE;
-
-#define CACHE_BUCKET_NAME(B)  ((B)->method_name)
-#define CACHE_BUCKET_IMP(B)   ((B)->method_imp)
-#define CACHE_BUCKET_VALID(B) (B)
-#ifndef __LP64__
-#define CACHE_HASH(sel, mask) (((uintptr_t)(sel)>>2) & (mask))
-#else
-#define CACHE_HASH(sel, mask) (((unsigned int)((uintptr_t)(sel)>>3)) & (mask))
-#endif
-struct objc_cache {
-    unsigned int mask /* total = mask + 1 */                 OBJC2_UNAVAILABLE;
-    unsigned int occupied                                    OBJC2_UNAVAILABLE;
-    Method _Nullable buckets[1]                              OBJC2_UNAVAILABLE;
-};
-
-
-typedef struct objc_module *Module                           OBJC2_UNAVAILABLE;
-
-struct objc_module {
-    unsigned long version                                    OBJC2_UNAVAILABLE;
-    unsigned long size                                       OBJC2_UNAVAILABLE;
-    const char * _Nullable name                              OBJC2_UNAVAILABLE;
-    Symtab _Nullable symtab                                  OBJC2_UNAVAILABLE;
-}                                                            OBJC2_UNAVAILABLE;
-
-#else
+// Modifiers
+#define _C_COMPLEX     'j'
+#define _C_ATOMIC      'A'
+#define _C_CONST       'r'
+#define _C_IN          'n'
+#define _C_INOUT       'N'
+#define _C_OUT         'o'
+#define _C_BYCOPY      'O'
+#define _C_BYREF       'R'
+#define _C_ONEWAY      'V'
+#define _C_GNUREGISTER '+'
 
 struct objc_method_list;
 
-#endif
-
-
 /* Obsolete functions */
 
+#if !0
+
 OBJC_EXPORT IMP _Nullable
 class_lookupMethod(Class _Nullable cls, SEL _Nonnull sel) 
     __OSX_DEPRECATED(10.0, 10.5, "use class_getMethodImplementation instead")
@@ -2062,108 +1932,11 @@ OBJC_EXPORT id _Nullable
 object_copyFromZone(id _Nullable anObject, size_t nBytes, void * _Nullable z) 
     OBJC_OSX_DEPRECATED_OTHERS_UNAVAILABLE(10.0, 10.5, "use object_copy instead");
 
-OBJC_EXPORT id _Nullable
-object_realloc(id _Nullable anObject, size_t nBytes)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT id _Nullable
-object_reallocFromZone(id _Nullable anObject, size_t nBytes, void * _Nullable z)
-    OBJC2_UNAVAILABLE;
-
-#define OBSOLETE_OBJC_GETCLASSES 1
-OBJC_EXPORT void * _Nonnull
-objc_getClasses(void)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT void
-objc_addClass(Class _Nonnull myClass)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT void
-objc_setClassHandler(int (* _Nullable )(const char * _Nonnull))
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT void
-objc_setMultithreaded(BOOL flag)
-    OBJC2_UNAVAILABLE;
-
 OBJC_EXPORT id _Nullable
 class_createInstanceFromZone(Class _Nullable, size_t idxIvars,
                              void * _Nullable z)
     OBJC_OSX_DEPRECATED_OTHERS_UNAVAILABLE(10.0, 10.5, "use class_createInstance instead");
 
-OBJC_EXPORT void
-class_addMethods(Class _Nullable, struct objc_method_list * _Nonnull)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT void
-class_removeMethods(Class _Nullable, struct objc_method_list * _Nonnull)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT void
-_objc_resolve_categories_for_class(Class _Nonnull cls)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT Class _Nonnull
-class_poseAs(Class _Nonnull imposter, Class _Nonnull original)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT unsigned int
-method_getSizeOfArguments(Method _Nonnull m)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT unsigned
-method_getArgumentInfo(struct objc_method * _Nonnull m, int arg,
-                       const char * _Nullable * _Nonnull type,
-                       int * _Nonnull offset)
-    UNAVAILABLE_ATTRIBUTE  // This function was accidentally deleted in 10.9.
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT Class _Nullable
-objc_getOrigClass(const char * _Nonnull name)
-    OBJC2_UNAVAILABLE;
-
-#define OBJC_NEXT_METHOD_LIST 1
-OBJC_EXPORT struct objc_method_list * _Nullable
-class_nextMethodList(Class _Nullable, void * _Nullable * _Nullable)
-    OBJC2_UNAVAILABLE;
-// usage for nextMethodList
-//
-// void *iterator = 0;
-// struct objc_method_list *mlist;
-// while ( mlist = class_nextMethodList( cls, &iterator ) )
-//    ;
- 
-OBJC_EXPORT id _Nullable
-(* _Nonnull _alloc)(Class _Nullable, size_t)
-    OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT id _Nullable
-(* _Nonnull _copy)(id _Nullable, size_t)
-     OBJC2_UNAVAILABLE;
-     
-OBJC_EXPORT id _Nullable
-(* _Nonnull _realloc)(id _Nullable, size_t)
-     OBJC2_UNAVAILABLE;
-
-OBJC_EXPORT id _Nullable
-(* _Nonnull _dealloc)(id _Nullable)
-     OBJC2_UNAVAILABLE;
-     
-OBJC_EXPORT id _Nullable
-(* _Nonnull _zoneAlloc)(Class _Nullable, size_t, void * _Nullable)
-     OBJC2_UNAVAILABLE;
-     
-OBJC_EXPORT id _Nullable
-(* _Nonnull _zoneRealloc)(id _Nullable, size_t, void * _Nullable)
-     OBJC2_UNAVAILABLE;
-     
-OBJC_EXPORT id _Nullable
-(* _Nonnull _zoneCopy)(id _Nullable, size_t, void * _Nullable)
-     OBJC2_UNAVAILABLE;
-     
-OBJC_EXPORT void
-(* _Nonnull _error)(id _Nullable, const char * _Nonnull, va_list)
-     OBJC2_UNAVAILABLE;
+#endif 
 
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/os/availability.h b/lib/libc/include/any-macos.13-any/os/availability.h
new file mode 100644
index 0000000000..ea0a9a8d14
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/os/availability.h
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) 2008-2017 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+ 
+#ifndef __OS_AVAILABILITY__
+#define __OS_AVAILABILITY__
+
+/* 
+ * API_TO_BE_DEPRECATED is used as a version number in API that will be deprecated 
+ * in an upcoming release. This soft deprecation is an intermediate step before formal 
+ * deprecation to notify developers about the API before compiler warnings are generated.
+ * You can find all places in your code that use soft deprecated API by redefining the 
+ * value of this macro to your current minimum deployment target, for example:
+ * (macOS)
+ *   clang -DAPI_TO_BE_DEPRECATED=10.12 <other compiler flags>
+ * (iOS)
+ *   clang -DAPI_TO_BE_DEPRECATED=11.0 <other compiler flags>
+ */
+ 
+#ifndef API_TO_BE_DEPRECATED
+#define API_TO_BE_DEPRECATED 100000
+#endif
+
+#ifndef API_TO_BE_DEPRECATED_MACOS
+#define API_TO_BE_DEPRECATED_MACOS 100000
+#endif
+
+#ifndef API_TO_BE_DEPRECATED_IOS
+#define API_TO_BE_DEPRECATED_IOS 100000
+#endif
+
+#ifndef API_TO_BE_DEPRECATED_TVOS
+#define API_TO_BE_DEPRECATED_TVOS 100000
+#endif
+
+#ifndef API_TO_BE_DEPRECATED_WATCHOS
+#define API_TO_BE_DEPRECATED_WATCHOS 100000
+#endif
+
+#ifndef __API_TO_BE_DEPRECATED_BRIDGEOS
+
+#endif
+
+#ifndef __API_TO_BE_DEPRECATED_MACCATALYST
+#define __API_TO_BE_DEPRECATED_MACCATALYST 100000
+#endif
+
+#ifndef API_TO_BE_DEPRECATED_DRIVERKIT
+#define API_TO_BE_DEPRECATED_DRIVERKIT 100000
+#endif
+
+
+
+#include <AvailabilityInternal.h>
+
+
+
+#if defined(__has_feature) && defined(__has_attribute)
+ #if __has_attribute(availability)
+
+    /*
+     * API Introductions
+     *
+     * Use to specify the release that a particular API became available.
+     *
+     * Platform names:
+     *   macos, ios, tvos, watchos
+     *
+     * Examples:
+     *    API_AVAILABLE(macos(10.10))
+     *    API_AVAILABLE(macos(10.9), ios(10.0))
+     *    API_AVAILABLE(macos(10.4), ios(8.0), watchos(2.0), tvos(10.0))
+     */
+
+    #define API_AVAILABLE(...) __API_AVAILABLE_GET_MACRO(__VA_ARGS__,__API_AVAILABLE8, __API_AVAILABLE7, __API_AVAILABLE6, __API_AVAILABLE5, __API_AVAILABLE4, __API_AVAILABLE3, __API_AVAILABLE2, __API_AVAILABLE1, 0)(__VA_ARGS__)
+
+    #define API_AVAILABLE_BEGIN(...) _Pragma("clang attribute push") __API_AVAILABLE_BEGIN_GET_MACRO(__VA_ARGS__,__API_AVAILABLE8,__API_AVAILABLE_BEGIN7,__API_AVAILABLE_BEGIN6, __API_AVAILABLE_BEGIN5, __API_AVAILABLE_BEGIN4, __API_AVAILABLE_BEGIN3, __API_AVAILABLE_BEGIN2, __API_AVAILABLE_BEGIN1, 0)(__VA_ARGS__)
+    #define API_AVAILABLE_END _Pragma("clang attribute pop")
+
+    /*
+     * API Deprecations
+     *
+     * Use to specify the release that a particular API became unavailable.
+     *
+     * Platform names:
+     *   macos, ios, tvos, watchos
+     *
+     * Examples:
+     *
+     *    API_DEPRECATED("No longer supported", macos(10.4, 10.8))
+     *    API_DEPRECATED("No longer supported", macos(10.4, 10.8), ios(2.0, 3.0), watchos(2.0, 3.0), tvos(9.0, 10.0))
+     *
+     *    API_DEPRECATED_WITH_REPLACEMENT("-setName:", tvos(10.0, 10.4), ios(9.0, 10.0))
+     *    API_DEPRECATED_WITH_REPLACEMENT("SomeClassName", macos(10.4, 10.6), watchos(2.0, 3.0))
+     */
+
+    #define API_DEPRECATED(...) __API_DEPRECATED_MSG_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_MSG9,__API_DEPRECATED_MSG8,__API_DEPRECATED_MSG7, __API_DEPRECATED_MSG6,__API_DEPRECATED_MSG5,__API_DEPRECATED_MSG4,__API_DEPRECATED_MSG3,__API_DEPRECATED_MSG2,__API_DEPRECATED_MSG1, 0)(__VA_ARGS__)
+    #define API_DEPRECATED_WITH_REPLACEMENT(...) __API_DEPRECATED_REP_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_REP9,__API_DEPRECATED_REP8,__API_DEPRECATED_REP7, __API_DEPRECATED_REP6,__API_DEPRECATED_REP5,__API_DEPRECATED_REP4,__API_DEPRECATED_REP3,__API_DEPRECATED_REP2,__API_DEPRECATED_REP1, 0)(__VA_ARGS__)
+
+    #define API_DEPRECATED_BEGIN(...) _Pragma("clang attribute push") __API_DEPRECATED_BEGIN_MSG_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_BEGIN_MSG9,__API_DEPRECATED_BEGIN_MSG8,__API_DEPRECATED_BEGIN_MSG7, __API_DEPRECATED_BEGIN_MSG6, __API_DEPRECATED_BEGIN_MSG5, __API_DEPRECATED_BEGIN_MSG4, __API_DEPRECATED_BEGIN_MSG3, __API_DEPRECATED_BEGIN_MSG2, __API_DEPRECATED_BEGIN_MSG1, 0)(__VA_ARGS__)
+    #define API_DEPRECATED_END _Pragma("clang attribute pop")
+
+    #define API_DEPRECATED_WITH_REPLACEMENT_BEGIN(...) _Pragma("clang attribute push") __API_DEPRECATED_BEGIN_REP_GET_MACRO(__VA_ARGS__,__API_DEPRECATED_BEGIN_REP9,__API_DEPRECATED_BEGIN_REP8,__API_DEPRECATED_BEGIN_REP7, __API_DEPRECATED_BEGIN_REP6, __API_DEPRECATED_BEGIN_REP5, __API_DEPRECATED_BEGIN_REP4, __API_DEPRECATED_BEGIN_REP3, __API_DEPRECATED_BEGIN_REP2, __API_DEPRECATED_BEGIN_REP1, 0)(__VA_ARGS__)
+    #define API_DEPRECATED_WITH_REPLACEMENT_END _Pragma("clang attribute pop")
+
+
+    /*
+     * API Unavailability
+     * Use to specify that an API is unavailable for a particular platform.
+     *
+     * Example:
+     *    API_UNAVAILABLE(macos)
+     *    API_UNAVAILABLE(watchos, tvos)
+     */
+
+    #define API_UNAVAILABLE(...) __API_UNAVAILABLE_GET_MACRO(__VA_ARGS__,__API_UNAVAILABLE8,__API_UNAVAILABLE7,__API_UNAVAILABLE6, __API_UNAVAILABLE5, __API_UNAVAILABLE4,__API_UNAVAILABLE3,__API_UNAVAILABLE2,__API_UNAVAILABLE1, 0)(__VA_ARGS__)
+
+    #define API_UNAVAILABLE_BEGIN(...) _Pragma("clang attribute push") __API_UNAVAILABLE_BEGIN_GET_MACRO(__VA_ARGS__,__API_UNAVAILABLE_BEGIN8,__API_UNAVAILABLE_BEGIN7,__API_UNAVAILABLE_BEGIN6, __API_UNAVAILABLE_BEGIN5, __API_UNAVAILABLE_BEGIN4, __API_UNAVAILABLE_BEGIN3, __API_UNAVAILABLE_BEGIN2, __API_UNAVAILABLE_BEGIN1, 0)(__VA_ARGS__)
+    #define API_UNAVAILABLE_END _Pragma("clang attribute pop")
+ #else
+
+    /* 
+     * Evaluate to nothing for compilers that don't support availability.
+     */
+   
+     #define API_AVAILABLE(...)
+     #define API_AVAILABLE_BEGIN(...)
+     #define API_AVAILABLE_END
+     #define API_DEPRECATED(...)
+     #define API_DEPRECATED_WITH_REPLACEMENT(...)
+     #define API_DEPRECATED_BEGIN(...)
+     #define API_DEPRECATED_END
+     #define API_DEPRECATED_WITH_REPLACEMENT_BEGIN(...)
+     #define API_DEPRECATED_WITH_REPLACEMENT_END
+     #define API_UNAVAILABLE(...)
+     #define API_UNAVAILABLE_BEGIN(...)
+     #define API_UNAVAILABLE_END
+ #endif /* __has_attribute(availability) */
+#else
+
+    /* 
+     * Evaluate to nothing for compilers that don't support clang language extensions.
+     */
+
+    #define API_AVAILABLE(...)
+    #define API_AVAILABLE_BEGIN(...)
+    #define API_AVAILABLE_END
+    #define API_DEPRECATED(...)
+    #define API_DEPRECATED_WITH_REPLACEMENT(...)
+    #define API_DEPRECATED_BEGIN(...)
+    #define API_DEPRECATED_END
+    #define API_DEPRECATED_WITH_REPLACEMENT_BEGIN(...)
+    #define API_DEPRECATED_WITH_REPLACEMENT_END
+    #define API_UNAVAILABLE(...)
+    #define API_UNAVAILABLE_BEGIN(...)
+    #define API_UNAVAILABLE_END
+#endif /* #if defined(__has_feature) && defined(__has_attribute) */
+
+#if __has_include(<AvailabilityProhibitedInternal.h>)
+  #include <AvailabilityProhibitedInternal.h>
+#endif
+
+/*
+ * If SPI decorations have not been defined elsewhere, disable them.
+ */
+
+#ifndef SPI_AVAILABLE
+  #define SPI_AVAILABLE(...)
+#endif
+
+#ifndef SPI_DEPRECATED
+  #define SPI_DEPRECATED(...)
+#endif
+
+#ifndef SPI_DEPRECATED_WITH_REPLACEMENT
+  #define SPI_DEPRECATED_WITH_REPLACEMENT(...)
+#endif
+
+#endif /* __OS_AVAILABILITY__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/os/base.h b/lib/libc/include/any-macos.13-any/os/base.h
similarity index 82%
rename from lib/libc/include/x86_64-macos.10-none/os/base.h
rename to lib/libc/include/any-macos.13-any/os/base.h
index a57f8373a4..ab587fa02b 100644
--- a/lib/libc/include/x86_64-macos.10-none/os/base.h
+++ b/lib/libc/include/any-macos.13-any/os/base.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008-2013 Apple Inc. All rights reserved.
+ * Copyright (c) 2008-2020 Apple Inc. All rights reserved.
  *
  * @APPLE_APACHE_LICENSE_HEADER_START@
  *
@@ -23,6 +23,7 @@
 
 #include <sys/cdefs.h>
 
+
 #ifndef __has_builtin
 #define __has_builtin(x) 0
 #endif
@@ -73,7 +74,7 @@
 #define OS_ALWAYS_INLINE __attribute__((__always_inline__))
 #define OS_TRANSPARENT_UNION __attribute__((__transparent_union__))
 #define OS_ALIGNED(n) __attribute__((__aligned__((n))))
-#define OS_FORMAT_PRINTF(x,y) __attribute__((__format__(printf,x,y)))
+#define OS_FORMAT_PRINTF(x, y) __attribute__((__format__(printf,x,y)))
 #define OS_EXPORT extern __attribute__((__visibility__("default")))
 #define OS_INLINE static __inline__
 #define OS_EXPECT(x, v) __builtin_expect((x), (v))
@@ -110,7 +111,7 @@
 #define OS_ALWAYS_INLINE
 #define OS_TRANSPARENT_UNION
 #define OS_ALIGNED(n)
-#define OS_FORMAT_PRINTF(x,y)
+#define OS_FORMAT_PRINTF(x, y)
 #define OS_EXPORT extern
 #define OS_INLINE static inline
 #define OS_EXPECT(x, v) (x)
@@ -124,6 +125,8 @@
 
 #if defined(__cplusplus) && defined(__clang__)
 #define OS_FALLTHROUGH [[clang::fallthrough]]
+#elif __has_attribute(fallthrough)
+#define OS_FALLTHROUGH __attribute__((__fallthrough__))
 #else
 #define OS_FALLTHROUGH
 #endif
@@ -148,6 +151,12 @@
 #define OS_OVERLOADABLE
 #endif
 
+#if __has_attribute(analyzer_suppress)
+#define OS_ANALYZER_SUPPRESS(RADAR) __attribute__((analyzer_suppress))
+#else
+#define OS_ANALYZER_SUPPRESS(RADAR)
+#endif
+
 #if __has_attribute(enum_extensibility)
 #define __OS_ENUM_ATTR __attribute__((enum_extensibility(open)))
 #define __OS_ENUM_ATTR_CLOSED __attribute__((enum_extensibility(closed)))
@@ -164,30 +173,21 @@
  * -Wassign-enum prevents you from assigning illegal values to a variable of the
  * enum type.
  */
-#ifndef __OPEN_SOURCE__
-/*!
- * @internal
- * <rdar://problem/37799789>
- */
-#endif // __OPEN_SOURCE__
 #define __OS_OPTIONS_ATTR __attribute__((flag_enum))
 #else
 #define __OS_OPTIONS_ATTR
 #endif // __has_attribute(flag_enum)
 
 #if __has_feature(objc_fixed_enum) || __has_extension(cxx_fixed_enum) || \
-		__has_extension(cxx_strong_enums)
+        __has_extension(cxx_strong_enums)
 #define OS_ENUM(_name, _type, ...) \
-		typedef enum : _type { __VA_ARGS__ } _name##_t
+	typedef enum : _type { __VA_ARGS__ } _name##_t
 #define OS_CLOSED_ENUM(_name, _type, ...) \
-		typedef enum : _type { __VA_ARGS__ } \
-			__OS_ENUM_ATTR_CLOSED _name##_t
+	typedef enum : _type { __VA_ARGS__ } __OS_ENUM_ATTR_CLOSED _name##_t
 #define OS_OPTIONS(_name, _type, ...) \
-		typedef enum : _type { __VA_ARGS__ } \
-			__OS_ENUM_ATTR __OS_OPTIONS_ATTR _name##_t
+	typedef enum : _type { __VA_ARGS__ } __OS_ENUM_ATTR __OS_OPTIONS_ATTR _name##_t
 #define OS_CLOSED_OPTIONS(_name, _type, ...) \
-		typedef enum : _type { __VA_ARGS__ } \
-			__OS_ENUM_ATTR_CLOSED __OS_OPTIONS_ATTR _name##_t
+	typedef enum : _type { __VA_ARGS__ } __OS_ENUM_ATTR_CLOSED __OS_OPTIONS_ATTR _name##_t
 #else
 /*!
  * There is unfortunately no good way in plain C to have both fixed-type enums
@@ -220,29 +220,36 @@
  * When compiling in ObjC or C++, both of the above assignments are illegal.
  */
 #define __OS_ENUM_C_FALLBACK(_name, _type, ...) \
-		typedef _type _name##_t; enum _name { __VA_ARGS__ }
+	typedef _type _name##_t; enum _name { __VA_ARGS__ }
 
 #define OS_ENUM(_name, _type, ...) \
-		typedef _type _name##_t; enum { __VA_ARGS__ }
+	typedef _type _name##_t; enum { __VA_ARGS__ }
 #define OS_CLOSED_ENUM(_name, _type, ...) \
-		__OS_ENUM_C_FALLBACK(_name, _type, ## __VA_ARGS__) \
-		__OS_ENUM_ATTR_CLOSED
+	__OS_ENUM_C_FALLBACK(_name, _type, ## __VA_ARGS__) \
+	__OS_ENUM_ATTR_CLOSED
 #define OS_OPTIONS(_name, _type, ...) \
-		__OS_ENUM_C_FALLBACK(_name, _type, ## __VA_ARGS__) \
-		__OS_ENUM_ATTR __OS_OPTIONS_ATTR
+	__OS_ENUM_C_FALLBACK(_name, _type, ## __VA_ARGS__) \
+	__OS_ENUM_ATTR __OS_OPTIONS_ATTR
 #define OS_CLOSED_OPTIONS(_name, _type, ...) \
-		__OS_ENUM_C_FALLBACK(_name, _type, ## __VA_ARGS__) \
-		__OS_ENUM_ATTR_CLOSED __OS_OPTIONS_ATTR
+	__OS_ENUM_C_FALLBACK(_name, _type, ## __VA_ARGS__) \
+	__OS_ENUM_ATTR_CLOSED __OS_OPTIONS_ATTR
 #endif // __has_feature(objc_fixed_enum) || __has_extension(cxx_strong_enums)
 
 #if __has_feature(attribute_availability_swift)
 // equivalent to __SWIFT_UNAVAILABLE from Availability.h
 #define OS_SWIFT_UNAVAILABLE(_msg) \
-		__attribute__((__availability__(swift, unavailable, message=_msg)))
+	__attribute__((__availability__(swift, unavailable, message=_msg)))
 #else
 #define OS_SWIFT_UNAVAILABLE(_msg)
 #endif
 
+#if __has_attribute(__swift_attr__)
+#define OS_SWIFT_UNAVAILABLE_FROM_ASYNC(msg) \
+	__attribute__((__swift_attr__("@_unavailableFromAsync(message: \"" msg "\")")))
+#else
+#define OS_SWIFT_UNAVAILABLE_FROM_ASYNC(msg)
+#endif
+
 #if __has_attribute(swift_private)
 # define OS_REFINED_FOR_SWIFT __attribute__((__swift_private__))
 #else
@@ -262,12 +269,12 @@
 
 #ifdef __GNUC__
 #define os_prevent_tail_call_optimization()  __asm__("")
-#define os_is_compile_time_constant(expr)  __builtin_constant_p(expr)
-#define os_compiler_barrier()  __asm__ __volatile__("" ::: "memory")
+#define os_is_compile_time_constant(expr)    __builtin_constant_p(expr)
+#define os_compiler_barrier()                __asm__ __volatile__("" ::: "memory")
 #else
 #define os_prevent_tail_call_optimization()  do { } while (0)
-#define os_is_compile_time_constant(expr)  0
-#define os_compiler_barrier()  do { } while (0)
+#define os_is_compile_time_constant(expr)    0
+#define os_compiler_barrier()                do { } while (0)
 #endif
 
 #if __has_attribute(not_tail_called)
@@ -276,6 +283,7 @@
 #define OS_NOT_TAIL_CALLED
 #endif
 
+
 typedef void (*os_function_t)(void *_Nullable);
 
 #ifdef __BLOCKS__
@@ -322,4 +330,13 @@ typedef void (*os_function_t)(void *_Nullable);
 typedef void (^os_block_t)(void);
 #endif
 
+
+
+#define OS_ASSUME_PTR_ABI_SINGLE_BEGIN __ASSUME_PTR_ABI_SINGLE_BEGIN
+#define OS_ASSUME_PTR_ABI_SINGLE_END __ASSUME_PTR_ABI_SINGLE_END
+#define OS_UNSAFE_INDEXABLE __unsafe_indexable
+#define OS_HEADER_INDEXABLE __header_indexable
+#define OS_COUNTED_BY(N) __counted_by(N)
+#define OS_SIZED_BY(N) __sized_by(N)
+
 #endif // __OS_BASE__
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/os/lock.h b/lib/libc/include/any-macos.13-any/os/lock.h
new file mode 100644
index 0000000000..e141d029f5
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/os/lock.h
@@ -0,0 +1,202 @@
+/*
+ * Copyright (c) 2016 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __OS_LOCK__
+#define __OS_LOCK__
+
+#include <Availability.h>
+#include <sys/cdefs.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <os/base.h>
+
+OS_ASSUME_NONNULL_BEGIN
+
+/*! @header
+ * Low-level lock API.
+ */
+
+#define OS_LOCK_API_VERSION 20160309
+
+__BEGIN_DECLS
+
+#define OS_UNFAIR_LOCK_AVAILABILITY \
+		__API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
+
+/*!
+ * @typedef os_unfair_lock
+ *
+ * @abstract
+ * Low-level lock that allows waiters to block efficiently on contention.
+ *
+ * os_unfair_lock is an appropriate lock for cases where simple and lightweight
+ * mutual exclusion is needed.
+ * It can be intrusively stored inline in a datastructure without needing a
+ * separate allocation, reducing memory consumption and cost of indirection.
+ * For situations where something more sophisticated like condition waits or
+ * FIFO ordering is needed, use appropriate higher level APIs such as those from
+ * the pthread or dispatch subsystems.
+ *
+ * The values stored in the lock should be considered opaque and implementation
+ * defined, they contain thread ownership information that the system may use
+ * to attempt to resolve priority inversions.
+ *
+ * This lock must be unlocked from the same thread that locked it, attempts to
+ * unlock from a different thread will cause an assertion aborting the process.
+ *
+ * This lock must not be accessed from multiple processes or threads via shared
+ * or multiply-mapped memory, because the lock implementation relies on the
+ * address of the lock value and identity of the owning process.
+ *
+ * Must be initialized with OS_UNFAIR_LOCK_INIT.
+ *
+ * @discussion
+ * The name 'unfair' indicates that there is no attempt at enforcing acquisition
+ * fairness, e.g. an unlocker can potentially immediately reacquire the lock
+ * before a woken up waiter gets an opportunity to attempt to acquire the lock.
+ * This is often advantageous for performance reasons, but also makes starvation
+ * of waiters a possibility.
+ *
+ * This lock is suitable as a drop-in replacement for the deprecated OSSpinLock,
+ * providing much better behavior under contention.
+ *
+ * In Swift, note that use of the `&` operator on an unfair lock can copy or move
+ * the lock memory, leading to misbehavior. Use an OSAllocatedUnfairLock to safely wrap
+ * access to the lock memory instead. If you use os_unfair_lock APIs directly,
+ * always make sure to store and use the lock in memory with a stable address.
+ */
+OS_UNFAIR_LOCK_AVAILABILITY
+typedef struct os_unfair_lock_s {
+	uint32_t _os_unfair_lock_opaque;
+} os_unfair_lock, *os_unfair_lock_t;
+
+#ifndef OS_UNFAIR_LOCK_INIT
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+#define OS_UNFAIR_LOCK_INIT ((os_unfair_lock){0})
+#elif defined(__cplusplus) && __cplusplus >= 201103L
+#define OS_UNFAIR_LOCK_INIT (os_unfair_lock{})
+#elif defined(__cplusplus)
+#define OS_UNFAIR_LOCK_INIT (os_unfair_lock())
+#else
+#define OS_UNFAIR_LOCK_INIT {0}
+#endif
+#endif // OS_UNFAIR_LOCK_INIT
+
+/*!
+ * @function os_unfair_lock_lock
+ *
+ * @abstract
+ * Locks an os_unfair_lock.
+ *
+ * @param lock
+ * Pointer to an os_unfair_lock.
+ */
+OS_UNFAIR_LOCK_AVAILABILITY
+OS_EXPORT OS_NOTHROW OS_NONNULL_ALL
+OS_SWIFT_UNAVAILABLE_FROM_ASYNC("Use OSAllocatedUnfairLock.performWhileLocked() for async-safe scoped locking")
+void os_unfair_lock_lock(os_unfair_lock_t lock);
+
+/*!
+ * @function os_unfair_lock_trylock
+ *
+ * @abstract
+ * Locks an os_unfair_lock if it is not already locked.
+ *
+ * @discussion
+ * It is invalid to surround this function with a retry loop, if this function
+ * returns false, the program must be able to proceed without having acquired
+ * the lock, or it must call os_unfair_lock_lock() directly (a retry loop around
+ * os_unfair_lock_trylock() amounts to an inefficient implementation of
+ * os_unfair_lock_lock() that hides the lock waiter from the system and prevents
+ * resolution of priority inversions).
+ *
+ * @param lock
+ * Pointer to an os_unfair_lock.
+ *
+ * @result
+ * Returns true if the lock was succesfully locked and false if the lock was
+ * already locked.
+ */
+OS_UNFAIR_LOCK_AVAILABILITY
+OS_EXPORT OS_NOTHROW OS_WARN_RESULT OS_NONNULL_ALL
+OS_SWIFT_UNAVAILABLE_FROM_ASYNC("Use OSAllocatedUnfairLock.tryPerformWhileLocked() for async-safe scoped locking")
+bool os_unfair_lock_trylock(os_unfair_lock_t lock);
+
+/*!
+ * @function os_unfair_lock_unlock
+ *
+ * @abstract
+ * Unlocks an os_unfair_lock.
+ *
+ * @param lock
+ * Pointer to an os_unfair_lock.
+ */
+OS_UNFAIR_LOCK_AVAILABILITY
+OS_EXPORT OS_NOTHROW OS_NONNULL_ALL
+OS_SWIFT_UNAVAILABLE_FROM_ASYNC("Use OSAllocatedUnfairLock.performWhileLocked() for async-safe scoped locking")
+void os_unfair_lock_unlock(os_unfair_lock_t lock);
+
+/*!
+ * @function os_unfair_lock_assert_owner
+ *
+ * @abstract
+ * Asserts that the calling thread is the current owner of the specified
+ * unfair lock.
+ *
+ * @discussion
+ * If the lock is currently owned by the calling thread, this function returns.
+ *
+ * If the lock is unlocked or owned by a different thread, this function
+ * asserts and terminates the process.
+ *
+ * @param lock
+ * Pointer to an os_unfair_lock.
+ */
+OS_UNFAIR_LOCK_AVAILABILITY
+OS_EXPORT OS_NOTHROW OS_NONNULL_ALL
+void os_unfair_lock_assert_owner(const os_unfair_lock *lock);
+
+/*!
+ * @function os_unfair_lock_assert_not_owner
+ *
+ * @abstract
+ * Asserts that the calling thread is not the current owner of the specified
+ * unfair lock.
+ *
+ * @discussion
+ * If the lock is unlocked or owned by a different thread, this function
+ * returns.
+ *
+ * If the lock is currently owned by the current thread, this function asserts
+ * and terminates the process.
+ *
+ * @param lock
+ * Pointer to an os_unfair_lock.
+ */
+OS_UNFAIR_LOCK_AVAILABILITY
+OS_EXPORT OS_NOTHROW OS_NONNULL_ALL
+void os_unfair_lock_assert_not_owner(const os_unfair_lock *lock);
+
+__END_DECLS
+
+OS_ASSUME_NONNULL_END
+
+#endif // __OS_LOCK__
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/os/object.h b/lib/libc/include/any-macos.13-any/os/object.h
similarity index 82%
rename from lib/libc/include/x86_64-macos.10-none/os/object.h
rename to lib/libc/include/any-macos.13-any/os/object.h
index be281bcd9a..4b5a77974a 100644
--- a/lib/libc/include/x86_64-macos.10-none/os/object.h
+++ b/lib/libc/include/any-macos.13-any/os/object.h
@@ -55,6 +55,9 @@
  * or iOS 6.0 deployment target.
  */
 
+#define OS_OBJECT_ASSUME_ABI_SINGLE_BEGIN	OS_ASSUME_PTR_ABI_SINGLE_BEGIN
+#define OS_OBJECT_ASSUME_ABI_SINGLE_END		OS_ASSUME_PTR_ABI_SINGLE_END
+
 #ifndef OS_OBJECT_HAVE_OBJC_SUPPORT
 #if !defined(__OBJC__) || defined(__OBJC_GC__)
 #  define OS_OBJECT_HAVE_OBJC_SUPPORT 0
@@ -98,6 +101,15 @@
 #endif // __swift__
 #endif // OS_OBJECT_SWIFT3
 
+#if __has_feature(assume_nonnull)
+#define OS_OBJECT_ASSUME_NONNULL_BEGIN _Pragma("clang assume_nonnull begin")
+#define OS_OBJECT_ASSUME_NONNULL_END   _Pragma("clang assume_nonnull end")
+#else
+#define OS_OBJECT_ASSUME_NONNULL_BEGIN
+#define OS_OBJECT_ASSUME_NONNULL_END
+#endif
+#define OS_OBJECT_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
+
 #if OS_OBJECT_USE_OBJC
 #import <objc/NSObject.h>
 #if __has_attribute(objc_independent_class)
@@ -116,9 +128,9 @@
 #define OS_OBJECT_CLASS_IMPLEMENTS_PROTOCOL(name, proto) \
 		OS_OBJECT_CLASS_IMPLEMENTS_PROTOCOL_IMPL( \
 				OS_OBJECT_CLASS(name), OS_OBJECT_CLASS(proto))
-#define OS_OBJECT_DECL_IMPL(name, ...) \
+#define OS_OBJECT_DECL_IMPL(name, adhere, ...) \
 		OS_OBJECT_DECL_PROTOCOL(name, __VA_ARGS__) \
-		typedef NSObject<OS_OBJECT_CLASS(name)> \
+		typedef adhere<OS_OBJECT_CLASS(name)> \
 				* OS_OBJC_INDEPENDENT_CLASS name##_t
 #define OS_OBJECT_DECL_BASE(name, ...) \
 		@interface OS_OBJECT_CLASS(name) : __VA_ARGS__ \
@@ -129,9 +141,9 @@
 		typedef OS_OBJECT_CLASS(name) \
 				* OS_OBJC_INDEPENDENT_CLASS name##_t
 #define OS_OBJECT_DECL(name, ...) \
-		OS_OBJECT_DECL_IMPL(name, <NSObject>)
+		OS_OBJECT_DECL_IMPL(name, NSObject, <NSObject>)
 #define OS_OBJECT_DECL_SUBCLASS(name, super) \
-		OS_OBJECT_DECL_IMPL(name, <OS_OBJECT_CLASS(super)>)
+		OS_OBJECT_DECL_IMPL(name, NSObject, <OS_OBJECT_CLASS(super)>)
 #if __has_attribute(ns_returns_retained)
 #define OS_OBJECT_RETURNS_RETAINED __attribute__((__ns_returns_retained__))
 #else
@@ -149,6 +161,8 @@
 #define OS_OBJECT_BRIDGE
 #define OS_WARN_RESULT_NEEDS_RELEASE OS_WARN_RESULT
 #endif
+
+
 #if __has_attribute(objc_runtime_visible) && \
 		((defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && \
 		__MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_12) || \
@@ -163,7 +177,7 @@
 /*
  * To provide backward deployment of ObjC objects in Swift on pre-10.12
  * SDKs, OS_object classes can be marked as OS_OBJECT_OBJC_RUNTIME_VISIBLE.
- * When compiling with a deployment target earlier than OS X 10.12 (iOS 10.0, 
+ * When compiling with a deployment target earlier than OS X 10.12 (iOS 10.0,
  * tvOS 10.0, watchOS 3.0) the Swift compiler will only refer to this type at
  * runtime (using the ObjC runtime).
  */
@@ -187,9 +201,9 @@
 #define OS_OBJECT_DECL_SUBCLASS_SWIFT(name, super) \
 		OS_EXPORT OS_OBJECT_OBJC_RUNTIME_VISIBLE \
 		OS_OBJECT_DECL_IMPL_CLASS(name, OS_OBJECT_CLASS(super))
+#endif // OS_OBJECT_SWIFT3
 OS_EXPORT OS_OBJECT_OBJC_RUNTIME_VISIBLE
 OS_OBJECT_DECL_BASE(object, NSObject);
-#endif // OS_OBJECT_SWIFT3
 #else
 /*! @parseOnly */
 #define OS_OBJECT_RETURNS_RETAINED
@@ -215,9 +229,31 @@ OS_OBJECT_DECL_BASE(object, NSObject);
 		typedef struct name##_s *name##_t
 #endif
 
+#if OS_OBJECT_USE_OBJC
+/* Declares a class of the specific name and exposes the interface and typedefs
+ * name##_t to the pointer to the class */
+#define OS_OBJECT_SHOW_CLASS(name, ...) \
+		OS_EXPORT OS_OBJECT_OBJC_RUNTIME_VISIBLE \
+		OS_OBJECT_DECL_IMPL_CLASS(name, ## __VA_ARGS__ )
+/* Declares a subclass of the same name, and
+ * subclass adheres to protocol specified. Typedefs baseclass<proto> * to subclass##_t */
+#define OS_OBJECT_SHOW_SUBCLASS(subclass_name, super, proto_name) \
+		OS_EXPORT OS_OBJECT_OBJC_RUNTIME_VISIBLE \
+		OS_OBJECT_DECL_BASE(subclass_name, OS_OBJECT_CLASS(super)<OS_OBJECT_CLASS(proto_name)>); \
+		typedef OS_OBJECT_CLASS(super)<OS_OBJECT_CLASS(proto_name)> \
+				* OS_OBJC_INDEPENDENT_CLASS subclass_name##_t
+#else /* Plain C */
+#define OS_OBJECT_DECL_PROTOCOL(name, ...)
+#define OS_OBJECT_SHOW_CLASS(name, ...) \
+		typedef struct name##_s *name##_t
+#define OS_OBJECT_SHOW_SUBCLASS(name, super, ...) \
+		typedef super##_t name##_t
+#endif
+
 #define OS_OBJECT_GLOBAL_OBJECT(type, object) ((OS_OBJECT_BRIDGE type)&(object))
 
 __BEGIN_DECLS
+OS_OBJECT_ASSUME_ABI_SINGLE_BEGIN
 
 /*!
  * @function os_retain
@@ -266,6 +302,7 @@ os_release(void *object);
 #define os_release(object) [object release]
 #endif
 
+OS_OBJECT_ASSUME_ABI_SINGLE_END
 __END_DECLS
 
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/os/workgroup_base.h b/lib/libc/include/any-macos.13-any/os/workgroup_base.h
new file mode 100644
index 0000000000..e705496f2a
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/os/workgroup_base.h
@@ -0,0 +1,85 @@
+#ifndef __OS_WORKGROUP_BASE__
+#define __OS_WORKGROUP_BASE__
+
+#ifndef __OS_WORKGROUP_INDIRECT__
+#error "Please #include <os/workgroup.h> instead of this file directly."
+#endif
+
+#include <sys/types.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <mach/port.h>
+
+#include <Availability.h>
+#include <os/base.h>
+#include <os/object.h>
+#include <os/clock.h>
+
+#if __has_feature(assume_nonnull)
+#define OS_WORKGROUP_ASSUME_NONNULL_BEGIN _Pragma("clang assume_nonnull begin")
+#define OS_WORKGROUP_ASSUME_NONNULL_END   _Pragma("clang assume_nonnull end")
+#else
+#define OS_WORKGROUP_ASSUME_NONNULL_BEGIN
+#define OS_WORKGROUP_ASSUME_NONNULL_END
+#endif
+#define OS_WORKGROUP_WARN_RESULT __attribute__((__warn_unused_result__))
+#define OS_WORKGROUP_EXPORT OS_EXPORT
+#define OS_WORKGROUP_RETURNS_RETAINED OS_OBJECT_RETURNS_RETAINED
+#define OS_WORKGROUP_ASSUME_ABI_SINGLE_BEGIN OS_ASSUME_PTR_ABI_SINGLE_BEGIN
+#define OS_WORKGROUP_ASSUME_ABI_SINGLE_END OS_ASSUME_PTR_ABI_SINGLE_END
+#define OS_WORKGROUP_UNSAFE_INDEXABLE OS_UNSAFE_INDEXABLE
+
+#define OS_WORKGROUP_DECL(name, swift_name) \
+	OS_SWIFT_NAME(swift_name) \
+	OS_OBJECT_SHOW_CLASS(name, OS_OBJECT_CLASS(object))
+
+#if OS_OBJECT_USE_OBJC
+#define OS_WORKGROUP_SUBCLASS_DECL_PROTO(name, swift_name, ...) \
+	OS_SWIFT_NAME(swift_name) \
+	OS_OBJECT_DECL_PROTOCOL(name ## __VA_ARGS__ )
+#else
+#define OS_WORKGROUP_SUBCLASS_DECL_PROTO(name, swift_name, ...)
+#endif
+
+#define OS_WORKGROUP_SUBCLASS_DECL(name, super, swift_name, ...) \
+	OS_SWIFT_NAME(swift_name) \
+	OS_OBJECT_SHOW_SUBCLASS(name, super, name, ## __VA_ARGS__)
+
+#if defined(__LP64__)
+#define __OS_WORKGROUP_ATTR_SIZE__ 60
+#define __OS_WORKGROUP_INTERVAL_DATA_SIZE__ 56
+#define __OS_WORKGROUP_JOIN_TOKEN_SIZE__ 36
+#else
+#define __OS_WORKGROUP_ATTR_SIZE__ 60
+#define __OS_WORKGROUP_INTERVAL_DATA_SIZE__ 56
+#define __OS_WORKGROUP_JOIN_TOKEN_SIZE__ 28
+#endif
+
+#define _OS_WORKGROUP_ATTR_SIG_DEFAULT_INIT 0x2FA863B4
+#define _OS_WORKGROUP_ATTR_SIG_EMPTY_INIT 0x2FA863C4
+
+OS_WORKGROUP_ASSUME_ABI_SINGLE_BEGIN
+
+struct OS_REFINED_FOR_SWIFT os_workgroup_attr_opaque_s {
+	uint32_t sig;
+	char opaque[__OS_WORKGROUP_ATTR_SIZE__];
+};
+
+#define _OS_WORKGROUP_INTERVAL_DATA_SIG_INIT 0x52A74C4D
+struct OS_REFINED_FOR_SWIFT os_workgroup_interval_data_opaque_s {
+	uint32_t sig;
+	char opaque[__OS_WORKGROUP_INTERVAL_DATA_SIZE__];
+};
+
+struct OS_REFINED_FOR_SWIFT os_workgroup_join_token_opaque_s {
+	uint32_t sig;
+	char opaque[__OS_WORKGROUP_JOIN_TOKEN_SIZE__];
+};
+
+OS_WORKGROUP_ASSUME_ABI_SINGLE_END
+
+#endif /* __OS_WORKGROUP_BASE__ */
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/os/workgroup_interval.h b/lib/libc/include/any-macos.13-any/os/workgroup_interval.h
new file mode 100644
index 0000000000..84aa507634
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/os/workgroup_interval.h
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2020 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __OS_WORKGROUP_INTERVAL__
+#define __OS_WORKGROUP_INTERVAL__
+
+#ifndef __OS_WORKGROUP_INDIRECT__
+#error "Please #include <os/workgroup.h> instead of this file directly."
+#include <os/workgroup_base.h> // For header doc
+#endif
+
+__BEGIN_DECLS
+
+OS_WORKGROUP_ASSUME_NONNULL_BEGIN
+OS_WORKGROUP_ASSUME_ABI_SINGLE_BEGIN
+
+/*!
+ * @typedef os_workgroup_interval_t
+ *
+ * @abstract
+ * A subclass of an os_workgroup_t for tracking work performed as part of
+ * a repeating interval-driven workload.
+ */
+OS_WORKGROUP_SUBCLASS_DECL_PROTO(os_workgroup_interval, Repeatable);
+OS_WORKGROUP_SUBCLASS_DECL(os_workgroup_interval, os_workgroup, WorkGroupInterval);
+
+/* During the first instance of this API, the only supported interval
+ * workgroups are for audio workloads. Please refer to the AudioToolbox
+ * framework for more information.
+ */
+
+/*
+ * @typedef os_workgroup_interval_data, os_workgroup_interval_data_t
+ *
+ * @abstract
+ * An opaque structure containing additional configuration for the workgroup
+ * interval.
+ */
+typedef struct os_workgroup_interval_data_opaque_s os_workgroup_interval_data_s;
+typedef struct os_workgroup_interval_data_opaque_s *os_workgroup_interval_data_t;
+#define OS_WORKGROUP_INTERVAL_DATA_INITIALIZER \
+	{ .sig = _OS_WORKGROUP_INTERVAL_DATA_SIG_INIT }
+
+/*!
+ * @function os_workgroup_interval_start
+ *
+ * @abstract
+ * Indicates to the system that the member threads of this
+ * os_workgroup_interval_t have begun working on an instance of the repeatable
+ * interval workload with the specified timestamps. This function is real time
+ * safe.
+ *
+ * This function will set and return an errno in the following cases:
+ *
+ * - The current thread is not a member of the os_workgroup_interval_t
+ * - The os_workgroup_interval_t has been cancelled
+ * - The timestamps passed in are malformed
+ * - os_workgroup_interval_start() was previously called on the
+ * os_workgroup_interval_t without an intervening os_workgroup_interval_finish()
+ * - A concurrent workgroup interval configuration operation is taking place.
+ *
+ * @param start
+ * Start timestamp specified in the os_clockid_t with which the
+ * os_workgroup_interval_t was created. This is generally a time in the past and
+ * indicates when the workgroup started working on an interval period
+ *
+ * @param deadline
+ * Deadline timestamp specified in the os_clockid_t with which the
+ * os_workgroup_interval_t was created. This specifies the deadline which the
+ * interval period would like to meet.
+ *
+ * @param data
+ * This field is currently unused and should be NULL
+ */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT OS_WORKGROUP_WARN_RESULT
+int
+os_workgroup_interval_start(os_workgroup_interval_t wg, uint64_t start, uint64_t
+		deadline, os_workgroup_interval_data_t _Nullable data);
+
+/*!
+ * @function os_workgroup_interval_update
+ *
+ * @abstract
+ * Updates an already started interval workgroup to have the new
+ * deadline specified. This function is real time safe.
+ *
+ * This function will return an error in the following cases:
+ * - The current thread is not a member of the os_workgroup_interval_t
+ * - The os_workgroup_interval_t has been cancelled
+ * - The timestamp passed in is malformed
+ * - os_workgroup_interval_start() was not previously called on the
+ * os_workgroup_interval_t or was already matched with an
+ * os_workgroup_interval_finish()
+ * - A concurrent workgroup interval configuration operation is taking place
+ *
+ * @param deadline
+ * Timestamp specified in the os_clockid_t with
+ * which the os_workgroup_interval_t was created.
+ *
+ * @param data
+ * This field is currently unused and should be NULL
+ */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT OS_WORKGROUP_WARN_RESULT
+int
+os_workgroup_interval_update(os_workgroup_interval_t wg, uint64_t deadline,
+		os_workgroup_interval_data_t _Nullable data);
+
+/*!
+ * @function os_workgroup_interval_finish
+ *
+ * @abstract
+ * Indicates to the system that the member threads of
+ * this os_workgroup_interval_t have finished working on the current instance
+ * of the interval workload. This function is real time safe.
+ *
+ * This function will return an error in the following cases:
+ *  - The current thread is not a member of the os_workgroup_interval_t
+ *  - os_workgroup_interval_start() was not previously called on the
+ * os_workgroup_interval_t or was already matched with an
+ * os_workgroup_interval_finish()
+ * - A concurrent workgroup interval configuration operation is taking place.
+ *
+ * @param data
+ * This field is currently unused and should be NULL
+ *
+ */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT OS_WORKGROUP_WARN_RESULT
+int
+os_workgroup_interval_finish(os_workgroup_interval_t wg,
+		os_workgroup_interval_data_t _Nullable data);
+
+OS_WORKGROUP_ASSUME_ABI_SINGLE_END
+OS_WORKGROUP_ASSUME_NONNULL_END
+
+__END_DECLS
+
+#endif /* __OS_WORKGROUP_INTERVAL__ */
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/os/workgroup_object.h b/lib/libc/include/any-macos.13-any/os/workgroup_object.h
new file mode 100644
index 0000000000..fdf5ae7211
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/os/workgroup_object.h
@@ -0,0 +1,359 @@
+/*
+ * Copyright (c) 2020 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __OS_WORKGROUP_OBJECT__
+#define __OS_WORKGROUP_OBJECT__
+
+#ifndef __OS_WORKGROUP_INDIRECT__
+#error "Please #include <os/workgroup.h> instead of this file directly."
+#include <os/workgroup_base.h> // For header doc
+#endif
+
+__BEGIN_DECLS
+
+OS_WORKGROUP_ASSUME_NONNULL_BEGIN
+OS_WORKGROUP_ASSUME_ABI_SINGLE_BEGIN
+
+/*!
+ * @typedef os_workgroup_t
+ *
+ * @abstract
+ * A reference counted os object representing a workload that needs to
+ * be distinctly recognized and tracked by the system.  The workgroup
+ * tracks a collection of threads all working cooperatively. An os_workgroup
+ * object - when not an instance of a specific os_workgroup_t subclass -
+ * represents a generic workload and makes no assumptions about the kind of
+ * work done.
+ *
+ * @discussion
+ * Threads can explicitly join an os_workgroup_t to mark themselves as
+ * participants in the workload.
+ */
+OS_WORKGROUP_DECL(os_workgroup, WorkGroup);
+
+
+/* Attribute creation and specification */
+
+/*!
+ * @typedef os_workgroup_attr_t
+ *
+ * @abstract
+ * Pointer to an opaque structure for describing attributes that can be
+ * configured on a workgroup at creation.
+ */
+typedef struct os_workgroup_attr_opaque_s os_workgroup_attr_s;
+typedef struct os_workgroup_attr_opaque_s *os_workgroup_attr_t;
+
+/* os_workgroup_t attributes need to be initialized before use. This initializer
+ * allows you to create a workgroup with the system default attributes. */
+#define OS_WORKGROUP_ATTR_INITIALIZER_DEFAULT \
+	{ .sig = _OS_WORKGROUP_ATTR_SIG_DEFAULT_INIT }
+
+
+
+/* The main use of the workgroup API is through instantiations of the concrete
+ * subclasses - please refer to os/workgroup_interval.h and
+ * os/workgroup_parallel.h for more information on creating workgroups.
+ *
+ * The functions below operate on all subclasses of os_workgroup_t.
+ */
+
+/*!
+ * @function os_workgroup_copy_port
+ *
+ * @abstract
+ * Returns a reference to a send right representing this workgroup that is to be
+ * sent to other processes. This port is to be passed to
+ * os_workgroup_create_with_port() to create a workgroup object.
+ *
+ * It is the client's responsibility to release the send right reference.
+ *
+ * If an error is encountered, errno is set and returned.
+ */
+API_AVAILABLE(macos(11.0))
+API_UNAVAILABLE(ios, tvos, watchos)
+OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT OS_WORKGROUP_WARN_RESULT
+int
+os_workgroup_copy_port(os_workgroup_t wg, mach_port_t *mach_port_out);
+
+/*!
+ * @function os_workgroup_create_with_port
+ *
+ * @abstract
+ * Create an os_workgroup_t object from a send right returned by a previous
+ * call to os_workgroup_copy_port, potentially in a different process.
+ *
+ * A newly created os_workgroup_t has no initial member threads - in particular
+ * the creating thread does not join the os_workgroup_t implicitly.
+ *
+ * @param name
+ * A client specified string for labelling the workgroup. This parameter is
+ * optional and can be NULL.
+ *
+ * @param mach_port
+ * The send right to create the workgroup from. No reference is consumed
+ * on the specified send right.
+ */
+API_AVAILABLE(macos(11.0))
+API_UNAVAILABLE(ios, tvos, watchos)
+OS_SWIFT_NAME(WorkGroup.init(__name:port:)) OS_WORKGROUP_EXPORT OS_WORKGROUP_RETURNS_RETAINED
+os_workgroup_t _Nullable
+os_workgroup_create_with_port(const char *OS_WORKGROUP_UNSAFE_INDEXABLE _Nullable name, mach_port_t mach_port);
+
+/*!
+ * @function os_workgroup_create_with_workgroup
+ *
+ * @abstract
+ * Create a new os_workgroup object from an existing os_workgroup.
+ *
+ * The newly created os_workgroup has no initial member threads - in particular
+ * the creating threaad does not join the os_workgroup_t implicitly.
+ *
+ * @param name
+ * A client specified string for labelling the workgroup. This parameter is
+ * optional and can be NULL.
+ *
+ * @param wg
+ * The existing workgroup to create a new workgroup object from.
+ */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT OS_WORKGROUP_RETURNS_RETAINED
+os_workgroup_t _Nullable
+os_workgroup_create_with_workgroup(const char * OS_WORKGROUP_UNSAFE_INDEXABLE _Nullable name, os_workgroup_t wg);
+
+/*!
+ * @typedef os_workgroup_join_token, os_workgroup_join_token_t
+ *
+ * @abstract
+ * An opaque join token which the client needs to pass to os_workgroup_join
+ * and os_workgroup_leave
+ */
+OS_REFINED_FOR_SWIFT
+typedef struct os_workgroup_join_token_opaque_s os_workgroup_join_token_s;
+OS_REFINED_FOR_SWIFT
+typedef struct os_workgroup_join_token_opaque_s *os_workgroup_join_token_t;
+
+
+/*!
+ * @function os_workgroup_join
+ *
+ * @abstract
+ * Joins the current thread to the specified workgroup and populates the join
+ * token that has been passed in. This API is real-time safe.
+ *
+ * @param wg
+ * The workgroup that the current thread would like to join
+ *
+ * @param token_out
+ * Pointer to a client allocated struct which the function will populate
+ * with the join token. This token must be passed in by the thread when it calls
+ * os_workgroup_leave().
+ *
+ * Errors will be returned in the following cases:
+ *
+ * EALREADY		The thread is already part of a workgroup that the specified
+ *				workgroup does not nest with
+ * EINVAL		The workgroup has been cancelled
+ */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT OS_WORKGROUP_WARN_RESULT
+int
+os_workgroup_join(os_workgroup_t wg, os_workgroup_join_token_t token_out);
+
+/*!
+ * @function os_workgroup_leave
+ *
+ * @abstract
+ * This removes the current thread from a workgroup it has previously
+ * joined. Threads must leave all workgroups in the reverse order that they
+ * have joined them. Failing to do so before exiting will result in undefined
+ * behavior.
+ *
+ * If the join token is malformed, the process will be aborted.
+ *
+ * This API is real time safe.
+ *
+ * @param wg
+ * The workgroup that the current thread would like to leave.
+ *
+ * @param token
+ * This is the join token populated by the most recent call to
+ * os_workgroup_join().
+ */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT
+void
+os_workgroup_leave(os_workgroup_t wg, os_workgroup_join_token_t token);
+
+/* Working Arena index of a thread in a workgroup */
+typedef uint32_t os_workgroup_index;
+/* Destructor for Working Arena */
+typedef void (*os_workgroup_working_arena_destructor_t)(void * _Nullable);
+
+/*!
+ * @function os_workgroup_set_working_arena
+ *
+ * @abstract
+ * Associates a client defined working arena with the workgroup. The arena
+ * is local to the workgroup object in the process. This is intended for
+ * distributing a manually managed memory allocation between member threads
+ * of the workgroup.
+ *
+ * This function can be called multiple times and the client specified
+ * destructor will be called on the previously assigned arena, if any. This
+ * function can only be called when no threads have currently joined the
+ * workgroup and all workloops associated with the workgroup are idle.
+ *
+ * @param wg
+ * The workgroup to associate the working arena with
+ *
+ * @param arena
+ * The client managed arena to associate with the workgroup. This value can
+ * be NULL.
+ *
+ * @param max_workers
+ * The maximum number of threads that will ever query the workgroup for the
+ * arena and request an index into it.  If the arena is not used to partition
+ * work amongst member threads, then this field can be 0.
+ *
+ * @param destructor
+ * A destructor to call on the previously assigned working arena, if any
+ */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT OS_WORKGROUP_WARN_RESULT
+int
+os_workgroup_set_working_arena(os_workgroup_t wg, void * _Nullable arena,
+	uint32_t max_workers, os_workgroup_working_arena_destructor_t destructor);
+
+/*!
+ * @function os_workgroup_get_working_arena
+ *
+ * @abstract
+ * Returns the working arena associated with the workgroup and the current
+ * thread's index in the workgroup. This function can only be called by a member
+ * of the workgroup. Multiple calls to this API by a member thread will return
+ * the same arena and index until the thread leaves the workgroup.
+ *
+ * For workloops with an associated workgroup, every work item on the workloop
+ * will receive the same index in the arena.
+ *
+ * This method returns NULL if no arena is set on the workgroup. The index
+ * returned by this function is zero-based and is namespaced per workgroup
+ * object in the process. The indices provided are strictly monotonic and never
+ * reused until a future call to os_workgroup_set_working_arena.
+ *
+ * @param wg
+ * The workgroup to get the working arena from.
+ *
+ * @param index_out
+ * A pointer to a os_workgroup_index which will be populated by the caller's
+ * index in the workgroup.
+ */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT
+void * _Nullable
+os_workgroup_get_working_arena(os_workgroup_t wg,
+		os_workgroup_index * _Nullable index_out);
+
+/*!
+ * @function os_workgroup_cancel
+ *
+ * @abstract
+ * This API invalidates a workgroup and indicates to the system that the
+ * workload is no longer relevant to the caller.
+ *
+ * No new work should be initiated for a cancelled workgroup and
+ * work that is already underway should periodically check for
+ * cancellation with os_workgroup_testcancel and initiate cleanup if needed.
+ *
+ * Threads currently in the workgroup continue to be tracked together but no
+ * new threads may join this workgroup - the only possible operation allowed is
+ * to leave the workgroup. Other actions may have undefined behavior or
+ * otherwise fail.
+ *
+ * This API is idempotent. Cancellation is local to the workgroup object
+ * it is called on and does not affect other workgroups.
+ *
+ * @param wg
+ * The workgroup that that the thread would like to cancel
+ */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT
+void
+os_workgroup_cancel(os_workgroup_t wg);
+
+/*!
+ * @function os_workgroup_testcancel
+ *
+ * @abstract
+ * Returns true if the workgroup object has been cancelled. See also
+ * os_workgroup_cancel
+ */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT
+bool
+os_workgroup_testcancel(os_workgroup_t wg);
+
+/*!
+ * @typedef os_workgroup_max_parallel_threads_attr_t
+ *
+ * @abstract
+ * A pointer to a structure describing the set of properties of a workgroup to
+ * override with the explicitly specified values in the structure.
+ *
+ * See also os_workgroup_max_parallel_threads.
+ */
+OS_REFINED_FOR_SWIFT
+typedef struct os_workgroup_max_parallel_threads_attr_s os_workgroup_mpt_attr_s;
+OS_REFINED_FOR_SWIFT
+typedef struct os_workgroup_max_parallel_threads_attr_s *os_workgroup_mpt_attr_t;
+
+/*!
+ * @function os_workgroup_max_parallel_threads
+ *
+ * @abstract
+ * Returns the system's recommendation for maximum number of threads the client
+ * should make for a multi-threaded workload in a given workgroup.
+ *
+ * This API takes into consideration the current hardware the code is running on
+ * and the attributes of the workgroup. It does not take into consideration the
+ * current load of the system and therefore always provides the most optimal
+ * recommendation for the workload.
+ *
+ * @param wg
+ * The workgroup in which the multi-threaded workload will be performed in. The
+ * threads performing the multi-threaded workload are expected to join this
+ * workgroup.
+ *
+ * @param attr
+ * This value is currently unused and should be NULL.
+ */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+OS_REFINED_FOR_SWIFT OS_WORKGROUP_EXPORT
+int
+os_workgroup_max_parallel_threads(os_workgroup_t wg, os_workgroup_mpt_attr_t
+		_Nullable attr);
+
+OS_WORKGROUP_ASSUME_ABI_SINGLE_END
+OS_WORKGROUP_ASSUME_NONNULL_END
+
+__END_DECLS
+
+#endif /* __OS_WORKGROUP_OBJECT__ */
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/os/workgroup_parallel.h b/lib/libc/include/any-macos.13-any/os/workgroup_parallel.h
new file mode 100644
index 0000000000..740e67b66c
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/os/workgroup_parallel.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2020 Apple Inc. All rights reserved.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_START@
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @APPLE_APACHE_LICENSE_HEADER_END@
+ */
+
+#ifndef __OS_WORKGROUP_PARALLEL__
+#define __OS_WORKGROUP_PARALLEL__
+
+#ifndef __OS_WORKGROUP_INDIRECT__
+#error "Please #include <os/workgroup.h> instead of this file directly."
+#include <os/workgroup_base.h> // For header doc
+#endif
+
+#include <os/workgroup_object.h>
+
+__BEGIN_DECLS
+
+OS_WORKGROUP_ASSUME_NONNULL_BEGIN
+OS_WORKGROUP_ASSUME_ABI_SINGLE_BEGIN
+
+/*!
+ * @typedef os_workgroup_parallel_t
+ *
+ * @abstract
+ * A subclass of an os_workgroup_t for tracking parallel work.
+ */
+OS_WORKGROUP_SUBCLASS_DECL_PROTO(os_workgroup_parallel, Parallelizable);
+OS_WORKGROUP_SUBCLASS_DECL(os_workgroup_parallel, os_workgroup, WorkGroupParallel);
+
+/*!
+ * @function os_workgroup_parallel_create
+ *
+ * @abstract
+ * Creates an os_workgroup_t which tracks a parallel workload.
+ * A newly created os_workgroup_interval_t has no initial member threads -
+ * in particular the creating thread does not join the os_workgroup_parallel_t
+ * implicitly.
+ *
+ * See also os_workgroup_max_parallel_threads().
+ *
+ * @param name
+ * A client specified string for labelling the workgroup. This parameter is
+ * optional and can be NULL.
+ *
+ * @param attr
+ * The requested set of workgroup attributes. NULL is to be specified for the
+ * default set of attributes.
+ */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+OS_WORKGROUP_EXPORT OS_WORKGROUP_RETURNS_RETAINED
+OS_SWIFT_NAME(WorkGroupParallel.init(__name:attr:))
+os_workgroup_parallel_t _Nullable
+os_workgroup_parallel_create(const char *OS_WORKGROUP_UNSAFE_INDEXABLE _Nullable name,
+	os_workgroup_attr_t _Nullable attr);
+
+OS_WORKGROUP_ASSUME_ABI_SINGLE_END
+OS_WORKGROUP_ASSUME_NONNULL_END
+
+__END_DECLS
+
+#endif /* __OS_WORKGROUP_PARALLEL__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/pthread.h b/lib/libc/include/any-macos.13-any/pthread.h
similarity index 66%
rename from lib/libc/include/x86_64-macos.10-none/pthread.h
rename to lib/libc/include/any-macos.13-any/pthread.h
index 0826a7dc70..7bc20229a3 100644
--- a/lib/libc/include/x86_64-macos.10-none/pthread.h
+++ b/lib/libc/include/any-macos.13-any/pthread.h
@@ -53,9 +53,6 @@
 #define _PTHREAD_H
 
 #include <_types.h>
-#ifndef __POSIX_LIB__
-#include <pthread/pthread_impl.h>
-#endif
 #include <pthread/sched.h>
 #include <time.h>
 #include <sys/_pthread/_pthread_types.h>
@@ -199,6 +196,13 @@ __BEGIN_DECLS
 #define _PTHREAD_SWIFT_IMPORTER_NULLABILITY_COMPAT \
 	defined(SWIFT_CLASS_EXTRA) && (!defined(SWIFT_SDK_OVERLAY_PTHREAD_EPOCH) || (SWIFT_SDK_OVERLAY_PTHREAD_EPOCH < 1))
 
+#if __has_attribute(__swift_attr__)
+#define __PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC(msg) \
+	__attribute__((__swift_attr__("@_unavailableFromAsync(message: \"" msg "\")")))
+#else
+#define __PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC(msg)
+#endif
+
 /*
  * Condition variable attributes
  */
@@ -305,12 +309,14 @@ __API_AVAILABLE(macos(10.4), ios(2.0))
 int pthread_cond_signal(pthread_cond_t *);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use an asynchronous wait instead of a synchronous wait")
 int pthread_cond_timedwait(
 		pthread_cond_t * __restrict, pthread_mutex_t * __restrict,
 		const struct timespec * _Nullable __restrict)
 		__DARWIN_ALIAS_C(pthread_cond_timedwait);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use an asynchronous wait instead of a synchronous wait")
 int pthread_cond_wait(pthread_cond_t * __restrict,
 		pthread_mutex_t * __restrict) __DARWIN_ALIAS_C(pthread_cond_wait);
 
@@ -346,6 +352,7 @@ __API_AVAILABLE(macos(10.4), ios(2.0))
 int pthread_equal(pthread_t _Nullable, pthread_t _Nullable);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Thread lifecycle is owned by Swift Concurrency runtime")
 void pthread_exit(void * _Nullable) __dead2;
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
@@ -355,10 +362,12 @@ __API_AVAILABLE(macos(10.4), ios(2.0))
 int pthread_getschedparam(pthread_t , int * _Nullable __restrict,
 		struct sched_param * _Nullable __restrict);
 
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use Task Local Values instead")
 __API_AVAILABLE(macos(10.4), ios(2.0))
 void* _Nullable pthread_getspecific(pthread_key_t);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use an asynchronous wait instead of a synchronous wait")
 int pthread_join(pthread_t , void * _Nullable * _Nullable)
 		__DARWIN_ALIAS_C(pthread_join);
 
@@ -380,6 +389,7 @@ int pthread_mutex_init(pthread_mutex_t * __restrict,
 		const pthread_mutexattr_t * _Nullable __restrict);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use OSAllocatedUnfairLock's withLock or NSLock for async-safe scoped locking")
 int pthread_mutex_lock(pthread_mutex_t *);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
@@ -387,9 +397,11 @@ int pthread_mutex_setprioceiling(pthread_mutex_t * __restrict, int,
 		int * __restrict);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use OSAllocatedUnfairLock's withLockIfAvailable or NSLock for async-safe scoped locking")
 int pthread_mutex_trylock(pthread_mutex_t *);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use OSAllocatedUnfairLock's withLock or NSLock for async-safe scoped locking")
 int pthread_mutex_unlock(pthread_mutex_t *);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
@@ -446,18 +458,23 @@ int pthread_rwlock_init(pthread_rwlock_t * __restrict,
 		__DARWIN_ALIAS(pthread_rwlock_init);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use async-safe scoped locking instead")
 int pthread_rwlock_rdlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_rdlock);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use async-safe scoped locking instead")
 int pthread_rwlock_tryrdlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_tryrdlock);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use async-safe scoped locking instead")
 int pthread_rwlock_trywrlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_trywrlock);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use async-safe scoped locking instead")
 int pthread_rwlock_wrlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_wrlock);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use async-safe scoped locking instead")
 int pthread_rwlock_unlock(pthread_rwlock_t *) __DARWIN_ALIAS(pthread_rwlock_unlock);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
@@ -477,10 +494,12 @@ __API_AVAILABLE(macos(10.4), ios(2.0))
 pthread_t pthread_self(void);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use Task cancellation instead")
 int pthread_setcancelstate(int , int * _Nullable)
 		__DARWIN_ALIAS(pthread_setcancelstate);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use Task cancellation instead")
 int pthread_setcanceltype(int , int * _Nullable)
 		__DARWIN_ALIAS(pthread_setcanceltype);
 
@@ -491,9 +510,11 @@ __API_AVAILABLE(macos(10.4), ios(2.0))
 int pthread_setschedparam(pthread_t, int, const struct sched_param *);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use Task Local Values instead")
 int pthread_setspecific(pthread_key_t , const void * _Nullable);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use Task cancellation instead")
 void pthread_testcancel(void) __DARWIN_ALIAS(pthread_testcancel);
 
 #if (!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || defined(_DARWIN_C_SOURCE) || defined(__cplusplus)
@@ -510,6 +531,7 @@ __API_AVAILABLE(macos(10.6), ios(3.2))
 int	pthread_getname_np(pthread_t,char*,size_t);
 
 __API_AVAILABLE(macos(10.6), ios(3.2))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Thread lifecycle is owned by Swift Concurrency runtime")
 int	pthread_setname_np(const char*);
 
 /* returns non-zero if the current thread is the main thread */
@@ -532,6 +554,7 @@ int pthread_cond_signal_thread_np(pthread_cond_t *, pthread_t _Nullable);
 
 /* Like pthread_cond_timedwait, but use a relative timeout */
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use an asynchronous wait instead of a synchronous wait")
 int pthread_cond_timedwait_relative_np(pthread_cond_t *, pthread_mutex_t *,
 		const struct timespec * _Nullable);
 
@@ -557,8 +580,171 @@ int pthread_sigmask(int, const sigset_t * _Nullable, sigset_t * _Nullable)
 		__DARWIN_ALIAS(pthread_sigmask);
 
 __API_AVAILABLE(macos(10.4), ios(2.0))
+__PTHREAD_SWIFT_UNAVAILABLE_FROM_ASYNC("Use Task.yield(), or await a condition instead of spinning")
 void pthread_yield_np(void);
 
+__API_AVAILABLE(macos(11.0))
+__API_UNAVAILABLE(ios, tvos, watchos, driverkit)
+void pthread_jit_write_protect_np(int enabled);
+
+__API_AVAILABLE(macos(11.0))
+__API_UNAVAILABLE(ios, tvos, watchos, driverkit)
+int pthread_jit_write_protect_supported_np(void);
+
+/*!
+ * @typedef pthread_jit_write_callback_t
+ * The type of a function that can be supplied to {@link
+ * pthread_jit_write_with_callback_np} to write to the MAP_JIT region while it
+ * is writeable.
+ *
+ * @param ctx
+ * A pointer to context that will be passed through to the callback function.
+ *
+ * @result
+ * A result code to be returned to the caller of @{link
+ * pthread_jit_write_with_callback_np}.  The system does not interpret/act on
+ * the value of this result.
+ */
+typedef int (*pthread_jit_write_callback_t)(void * _Nullable ctx);
+
+/*!
+ * @define PTHREAD_JIT_WRITE_ALLOW_CALLBACKS_NP
+ * A macro to be used at file scope to list the functions allowed to be passed
+ * to {@link pthread_jit_write_with_callback_np} to write to the MAP_JIT region
+ * while it is writeable.  It may be invoked only once per executable/library.
+ *
+ * @param callbacks
+ * The pthread_jit_write_callback_t functions to allow.  They should be supplied
+ * as a comma-delimited list.
+ */
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__OBJC__) || defined(__cplusplus)
+#define PTHREAD_JIT_WRITE_ALLOW_CALLBACKS_NP(...) \
+		__attribute__((__used__, __section__("__DATA_CONST,__pth_jit_func"))) \
+		static const pthread_jit_write_callback_t __pthread_jit_write_callback_allowlist[] = { \
+			__VA_ARGS__, NULL \
+		}
+#endif /* (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__OBJC__) || defined(__cplusplus) */
+
+/*!
+ * @function pthread_jit_write_with_callback_np
+ *
+ * @abstract
+ * Toggles per-thread write-protection of the MAP_JIT region to writeable,
+ * invokes an allowed callback function to write to it, and toggles protection
+ * back to executable.
+ *
+ * @param callback
+ * The callback function to invoke to write to the MAP_JIT region.  It must be
+ * statically allowed using {@link PTHREAD_JIT_WRITE_ALLOW_CALLBACKS_NP}.
+ *
+ * @param ctx
+ * Context to pass through to the invocation of the callback function.
+ *
+ * @result
+ * The result code returned by the callback function.
+ *
+ * @discussion
+ * This function assumes that the MAP_JIT region has executable protection when
+ * called.  It is therefore invalid to call it recursively from within a write
+ * callback.  The implementation does not detect such invalid recursive calls,
+ * so the client is responsible for preventing them.
+ *
+ * Callbacks _must not_ perform any non-local transfer of control flow (e.g.
+ * throw an exception, longjmp(3)), as doing so would leave the MAP_JIT region
+ * writeable.
+ *
+ * On systems where pthread_jit_write_protect_supported_np(3) is false, this
+ * function calls @callback directly and does nothing else.
+ *
+ * This function only enforces that @callback is allowed if the caller has the
+ * com.apple.security.cs.jit-write-allowlist entitlement.  That entitlement also
+ * disallows use of pthread_jit_write_protect_np(3).  Adopting the entitlement
+ * is therefore crucial in realizing the security benefits of this interface.
+ *
+ * If the entitlement is not present then this function toggles protection of
+ * the MAP_JIT to writeable, calls @callback and then toggles protection back to
+ * executable, without validating that @callback is an allowed function.  This
+ * behavior is intended to permit independent adoption of this interface by
+ * libraries - once all libraries in an application have adopted, the
+ * application should add the entitlement.
+ *
+ * By default, only callbacks in libraries/images present at process start-up
+ * are allowed - callbacks in images loaded dynamically via dlopen(3)/etc. are
+ * not permitted.  However, if the additional entitlement
+ * com.apple.security.cs.jit-write-allowlist-freeze-late is _also_ present, any
+ * callbacks in dlopen'd libraries are also added to the set of allowed
+ * callbacks until the {@link pthread_jit_write_freeze_callbacks_np} function is
+ * called.
+ *
+ * The goal of this interface is to allow applications that execute JIT-compiled
+ * code to mitigate against attempts from attackers to escalate to code
+ * execution by getting their own instructions written to the MAP_JIT region.
+ *
+ * Callbacks should assume an attacker can control the input to this function.
+ * They must therefore carefully validate the data that they are passed and do
+ * so using as little attackable state as possible. This means simplifying
+ * control flow and avoiding spills of sensitive registers (e.g. those used for
+ * validation or control flow).
+ *
+ * In the event a callback detects that its input is invalid, it should either
+ * abort in the simplest fashion possible (preferring e.g. __builtin_trap() over
+ * abort(3), the latter being encumbered by various conformance requirements) or
+ * return a result indicating failure.
+ */
+__API_AVAILABLE(macos(11.4))
+__API_UNAVAILABLE(ios, tvos, watchos, driverkit)
+__SWIFT_UNAVAILABLE_MSG("This interface cannot be safely used from Swift")
+int pthread_jit_write_with_callback_np(
+		pthread_jit_write_callback_t _Nonnull callback, void * _Nullable ctx);
+
+/*!
+ * @function pthread_jit_write_freeze_callbacks_np
+ *
+ * @abstract
+ * Freezes the set of allowed pthread JIT write callbacks, preventing any
+ * callbacks in subsequently dlopen'd libraries from being allowed as arguments
+ * to {@link pthread_jit_write_with_callback_np}
+ *
+ * @discussion
+ * If the com.apple.security.cs.jit-write-allowlist-freeze-late entitlement is
+ * present, this function must be called exactly once after all libraries
+ * containing JIT write callbacks have been loaded to prevent any further
+ * runtime modifications to the set of allowed callbacks.  Failing to call this
+ * function before calling pthread_jit_write_with_callback_np(3) for the first
+ * time is an error, as is calling it multiple times.
+ *
+ * If the jit-write-allowlist-freeze-late entitlement is not present, calling
+ * this function is an error.
+ *
+ * If an application does not need to dlopen(3) any libraries or frameworks
+ * containing needed JIT write callbacks, it is best to avoid the
+ * jit-write-allowlist-freeze-late entitlement and accompanying need to call
+ * this function, as this allows the runtime to automatically freeze the set of
+ * allowed callbacks early in process initialization.
+ */
+__API_AVAILABLE(macos(12.1))
+__API_UNAVAILABLE(ios, tvos, watchos, driverkit)
+void pthread_jit_write_freeze_callbacks_np(void);
+
+/*!
+ * @function pthread_cpu_number_np
+ *
+ * @param cpu_number_out
+ * The CPU number that the thread was running on at the time of query.
+ * This cpu number is in the interval [0, ncpus) (from sysctlbyname("hw.ncpu"))
+ *
+ * @result
+ * This function returns 0 or the value of errno if an error occurred.
+ *
+ * @note
+ * Optimizations of per-CPU datastructures based on the result of this function
+ * still require synchronization since it is not guaranteed that the thread will
+ * still be on the same CPU by the time the function returns.
+ */
+__API_AVAILABLE(macos(11.0), ios(14.2), tvos(14.2), watchos(7.1))
+int
+pthread_cpu_number_np(size_t *cpu_number_out);
+
 #endif /* (!_POSIX_C_SOURCE && !_XOPEN_SOURCE) || _DARWIN_C_SOURCE || __cplusplus */
 __END_DECLS
 #if __has_feature(assume_nonnull)
diff --git a/lib/libc/include/x86_64-macos.10-none/simd/base.h b/lib/libc/include/any-macos.13-any/simd/base.h
similarity index 84%
rename from lib/libc/include/x86_64-macos.10-none/simd/base.h
rename to lib/libc/include/any-macos.13-any/simd/base.h
index fdc2e3c879..fe3b05e356 100644
--- a/lib/libc/include/x86_64-macos.10-none/simd/base.h
+++ b/lib/libc/include/any-macos.13-any/simd/base.h
@@ -41,7 +41,21 @@
  *  way in which simd functions are overloaded, the usual weak-linking tricks
  *  do not work; these functions are simply unavailable when targeting older
  *  versions of the library.                                                  */
-#   if   __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_13   || \
+#   if   __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_13_0   || \
+        __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_16_0 || \
+        __WATCH_OS_VERSION_MIN_REQUIRED  >= __WATCHOS_9_0 || \
+        __TV_OS_VERSION_MIN_REQUIRED     >= __TVOS_16_0   || \
+        __BRIDGE_OS_VERSION_MIN_REQUIRED >= 70000   || \
+        __DRIVERKIT_VERSION_MIN_REQUIRED >= __DRIVERKIT_22_0
+#    define SIMD_LIBRARY_VERSION 5
+#   elif   __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_12_0   || \
+        __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_15_0 || \
+         __WATCH_OS_VERSION_MIN_REQUIRED >= __WATCHOS_8_0 || \
+            __TV_OS_VERSION_MIN_REQUIRED >= __TVOS_15_0   || \
+        __BRIDGE_OS_VERSION_MIN_REQUIRED >= 60000   || \
+        __DRIVERKIT_VERSION_MIN_REQUIRED >= __DRIVERKIT_21_0
+#    define SIMD_LIBRARY_VERSION 4
+#   elif __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_13   || \
         __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_11_0 || \
          __WATCH_OS_VERSION_MIN_REQUIRED >= __WATCHOS_4_0 || \
             __TV_OS_VERSION_MIN_REQUIRED >= __TVOS_11_0   || \
diff --git a/lib/libc/include/x86_64-macos.10-none/simd/math.h b/lib/libc/include/any-macos.13-any/simd/math.h
similarity index 81%
rename from lib/libc/include/x86_64-macos.10-none/simd/math.h
rename to lib/libc/include/any-macos.13-any/simd/math.h
index 5e2b31cae2..9b8ce556f0 100644
--- a/lib/libc/include/x86_64-macos.10-none/simd/math.h
+++ b/lib/libc/include/any-macos.13-any/simd/math.h
@@ -25,10 +25,12 @@
  *    cos(x)        simd::cos(x)
  *    sin(x)        simd::sin(x)
  *    tan(x)        simd::tan(x)
- *    
+ *    sincos(x)     simd::sincos(x)   Computes sin(x) and cos(x) more efficiently
+ *
  *    cospi(x)      simd::cospi(x)    Returns cos(pi*x), sin(pi*x), tan(pi*x)
  *    sinpi(x)      simd::sinpi(x)    more efficiently and accurately than
  *    tanpi(x)      simd::tanpi(x)    would otherwise be possible
+ *    sincospi(x)   simd::sincospi(x) Computes sin(pi*x) and cos(pi*x) more efficiently
  *
  *    acosh(x)      simd::acosh(x)
  *    asinh(x)      simd::asinh(x)
@@ -58,6 +60,7 @@
  *    erf(x)        simd::erf(x)
  *    erfc(x)       simd::erfc(x)
  *    tgamma(x)     simd::tgamma(x)
+ *    lgamma(x)     simd::lgamma(x)
  *
  *    fmod(x,y)      simd::fmod(x,y)
  *    remainder(x,y) simd::remainder(x,y)
@@ -78,7 +81,6 @@
  *                                    and later; may be quite expensive on
  *                                    older hardware.
  *    simd_muladd(x,y,z) simd::muladd(x,y,z)
- *
  *  @copyright 2014-2017 Apple, Inc. All rights reserved.
  *  @unsorted                                                                 */
 
@@ -913,6 +915,34 @@ static inline SIMD_CFUNC simd_double4 __tg_tgamma(simd_double4 x);
  *  Objective-C, and `simd::tgamma` in C++.                                   */
 static inline SIMD_CFUNC simd_double8 __tg_tgamma(simd_double8 x);
 
+/*! @abstract Do not call this function; instead use `lgamma` in C and
+ *  Objective-C, and `simd::lgamma` in C++.                                   */
+static inline SIMD_CFUNC simd_float2 __tg_lgamma(simd_float2 x);
+/*! @abstract Do not call this function; instead use `lgamma` in C and
+ *  Objective-C, and `simd::lgamma` in C++.                                   */
+static inline SIMD_CFUNC simd_float3 __tg_lgamma(simd_float3 x);
+/*! @abstract Do not call this function; instead use `lgamma` in C and
+ *  Objective-C, and `simd::lgamma` in C++.                                   */
+static inline SIMD_CFUNC simd_float4 __tg_lgamma(simd_float4 x);
+/*! @abstract Do not call this function; instead use `lgamma` in C and
+ *  Objective-C, and `simd::lgamma` in C++.                                   */
+static inline SIMD_CFUNC simd_float8 __tg_lgamma(simd_float8 x);
+/*! @abstract Do not call this function; instead use `lgamma` in C and
+ *  Objective-C, and `simd::lgamma` in C++.                                   */
+static inline SIMD_CFUNC simd_float16 __tg_lgamma(simd_float16 x);
+/*! @abstract Do not call this function; instead use `lgamma` in C and
+ *  Objective-C, and `simd::lgamma` in C++.                                   */
+static inline SIMD_CFUNC simd_double2 __tg_lgamma(simd_double2 x);
+/*! @abstract Do not call this function; instead use `lgamma` in C and
+ *  Objective-C, and `simd::lgamma` in C++.                                   */
+static inline SIMD_CFUNC simd_double3 __tg_lgamma(simd_double3 x);
+/*! @abstract Do not call this function; instead use `lgamma` in C and
+ *  Objective-C, and `simd::lgamma` in C++.                                   */
+static inline SIMD_CFUNC simd_double4 __tg_lgamma(simd_double4 x);
+/*! @abstract Do not call this function; instead use `lgamma` in C and
+ *  Objective-C, and `simd::lgamma` in C++.                                   */
+static inline SIMD_CFUNC simd_double8 __tg_lgamma(simd_double8 x);
+
 /*! @abstract Do not call this function; instead use `ceil` in C and
  *  Objective-C, and `simd::ceil` in C++.                                     */
 static inline SIMD_CFUNC simd_float2 __tg_ceil(simd_float2 x);
@@ -1053,7 +1083,177 @@ static inline SIMD_CFUNC simd_double4 __tg_trunc(simd_double4 x);
  *  Objective-C, and `simd::trunc` in C++.                                    */
 static inline SIMD_CFUNC simd_double8 __tg_trunc(simd_double8 x);
 
-    
+#if SIMD_LIBRARY_VERSION >= 5
+/*! @abstract Do not call this function; instead use `sincos` in C and
+ *  Objective-C, and `simd::sincos` in C++.                                   */
+static inline SIMD_NONCONST void __tg_sincos(simd_float2 x, simd_float2 *sinp, simd_float2 *cosp);
+/*! @abstract Do not call this function; instead use `sincos` in C and
+ *  Objective-C, and `simd::sincos` in C++.                                   */
+static inline SIMD_NONCONST void __tg_sincos(simd_float3 x, simd_float3 *sinp, simd_float3 *cosp);
+/*! @abstract Do not call this function; instead use `sincos` in C and
+ *  Objective-C, and `simd::sincos` in C++.                                   */
+static inline SIMD_NONCONST void __tg_sincos(simd_float4 x, simd_float4 *sinp, simd_float4 *cosp);
+/*! @abstract Do not call this function; instead use `sincos` in C and
+ *  Objective-C, and `simd::sincos` in C++.                                   */
+static inline SIMD_NONCONST void __tg_sincos(simd_float8 x, simd_float8 *sinp, simd_float8 *cosp);
+/*! @abstract Do not call this function; instead use `sincos` in C and
+ *  Objective-C, and `simd::sincos` in C++.                                   */
+static inline SIMD_NONCONST void __tg_sincos(simd_float16 x, simd_float16 *sinp, simd_float16 *cosp);
+/*! @abstract Do not call this function; instead use `sincos` in C and
+ *  Objective-C, and `simd::sincos` in C++.                                   */
+static inline SIMD_NONCONST void __tg_sincos(simd_double2 x, simd_double2 *sinp, simd_double2 *cosp);
+/*! @abstract Do not call this function; instead use `sincos` in C and
+ *  Objective-C, and `simd::sincos` in C++.                                   */
+static inline SIMD_NONCONST void __tg_sincos(simd_double3 x, simd_double3 *sinp, simd_double3 *cosp);
+/*! @abstract Do not call this function; instead use `sincos` in C and
+ *  Objective-C, and `simd::sincos` in C++.                                   */
+static inline SIMD_NONCONST void __tg_sincos(simd_double4 x, simd_double4 *sinp, simd_double4 *cosp);
+/*! @abstract Do not call this function; instead use `sincos` in C and
+ *  Objective-C, and `simd::sincos` in C++.                                   */
+static inline SIMD_NONCONST void __tg_sincos(simd_double8 x, simd_double8 *sinp, simd_double8 *cosp);
+
+/*! @abstract Do not call this function; instead use `sincospi` in C and
+ *  Objective-C, and `simd::sincospi` in C++.                                 */
+static inline SIMD_NONCONST void __tg_sincospi(simd_float2 x, simd_float2 *sinp, simd_float2 *cosp);
+/*! @abstract Do not call this function; instead use `sincospi` in C and
+ *  Objective-C, and `simd::sincospi` in C++.                                 */
+static inline SIMD_NONCONST void __tg_sincospi(simd_float3 x, simd_float3 *sinp, simd_float3 *cosp);
+/*! @abstract Do not call this function; instead use `sincospi` in C and
+ *  Objective-C, and `simd::sincospi` in C++.                                 */
+static inline SIMD_NONCONST void __tg_sincospi(simd_float4 x, simd_float4 *sinp, simd_float4 *cosp);
+/*! @abstract Do not call this function; instead use `sincospi` in C and
+ *  Objective-C, and `simd::sincospi` in C++.                                 */
+static inline SIMD_NONCONST void __tg_sincospi(simd_float8 x, simd_float8 *sinp, simd_float8 *cosp);
+/*! @abstract Do not call this function; instead use `sincospi` in C and
+ *  Objective-C, and `simd::sincospi` in C++.                                 */
+static inline SIMD_NONCONST void __tg_sincospi(simd_float16 x, simd_float16 *sinp, simd_float16 *cosp);
+/*! @abstract Do not call this function; instead use `sincospi` in C and
+ *  Objective-C, and `simd::sincospi` in C++.                                 */
+static inline SIMD_NONCONST void __tg_sincospi(simd_double2 x, simd_double2 *sinp, simd_double2 *cosp);
+/*! @abstract Do not call this function; instead use `sincospi` in C and
+ *  Objective-C, and `simd::sincospi` in C++.                                 */
+static inline SIMD_NONCONST void __tg_sincospi(simd_double3 x, simd_double3 *sinp, simd_double3 *cosp);
+/*! @abstract Do not call this function; instead use `sincospi` in C and
+ *  Objective-C, and `simd::sincospi` in C++.                                 */
+static inline SIMD_NONCONST void __tg_sincospi(simd_double4 x, simd_double4 *sinp, simd_double4 *cosp);
+/*! @abstract Do not call this function; instead use `sincospi` in C and
+ *  Objective-C, and `simd::sincospi` in C++.                                 */
+static inline SIMD_NONCONST void __tg_sincospi(simd_double8 x, simd_double8 *sinp, simd_double8 *cosp);
+
+#endif
+/*! @abstract Do not call this function; instead use `isfinite` in C and
+ *  Objective-C, and `simd::isfinite` in C++.                                 */
+static inline SIMD_CFUNC simd_int2 __tg_isfinite(simd_float2 x);
+/*! @abstract Do not call this function; instead use `isfinite` in C and
+ *  Objective-C, and `simd::isfinite` in C++.                                 */
+static inline SIMD_CFUNC simd_int3 __tg_isfinite(simd_float3 x);
+/*! @abstract Do not call this function; instead use `isfinite` in C and
+ *  Objective-C, and `simd::isfinite` in C++.                                 */
+static inline SIMD_CFUNC simd_int4 __tg_isfinite(simd_float4 x);
+/*! @abstract Do not call this function; instead use `isfinite` in C and
+ *  Objective-C, and `simd::isfinite` in C++.                                 */
+static inline SIMD_CFUNC simd_int8 __tg_isfinite(simd_float8 x);
+/*! @abstract Do not call this function; instead use `isfinite` in C and
+ *  Objective-C, and `simd::isfinite` in C++.                                 */
+static inline SIMD_CFUNC simd_int16 __tg_isfinite(simd_float16 x);
+/*! @abstract Do not call this function; instead use `isfinite` in C and
+ *  Objective-C, and `simd::isfinite` in C++.                                 */
+static inline SIMD_CFUNC simd_long2 __tg_isfinite(simd_double2 x);
+/*! @abstract Do not call this function; instead use `isfinite` in C and
+ *  Objective-C, and `simd::isfinite` in C++.                                 */
+static inline SIMD_CFUNC simd_long3 __tg_isfinite(simd_double3 x);
+/*! @abstract Do not call this function; instead use `isfinite` in C and
+ *  Objective-C, and `simd::isfinite` in C++.                                 */
+static inline SIMD_CFUNC simd_long4 __tg_isfinite(simd_double4 x);
+/*! @abstract Do not call this function; instead use `isfinite` in C and
+ *  Objective-C, and `simd::isfinite` in C++.                                 */
+static inline SIMD_CFUNC simd_long8 __tg_isfinite(simd_double8 x);
+
+/*! @abstract Do not call this function; instead use `isinf` in C and
+ *  Objective-C, and `simd::isinf` in C++.                                    */
+static inline SIMD_CFUNC simd_int2 __tg_isinf(simd_float2 x);
+/*! @abstract Do not call this function; instead use `isinf` in C and
+ *  Objective-C, and `simd::isinf` in C++.                                    */
+static inline SIMD_CFUNC simd_int3 __tg_isinf(simd_float3 x);
+/*! @abstract Do not call this function; instead use `isinf` in C and
+ *  Objective-C, and `simd::isinf` in C++.                                    */
+static inline SIMD_CFUNC simd_int4 __tg_isinf(simd_float4 x);
+/*! @abstract Do not call this function; instead use `isinf` in C and
+ *  Objective-C, and `simd::isinf` in C++.                                    */
+static inline SIMD_CFUNC simd_int8 __tg_isinf(simd_float8 x);
+/*! @abstract Do not call this function; instead use `isinf` in C and
+ *  Objective-C, and `simd::isinf` in C++.                                    */
+static inline SIMD_CFUNC simd_int16 __tg_isinf(simd_float16 x);
+/*! @abstract Do not call this function; instead use `isinf` in C and
+ *  Objective-C, and `simd::isinf` in C++.                                    */
+static inline SIMD_CFUNC simd_long2 __tg_isinf(simd_double2 x);
+/*! @abstract Do not call this function; instead use `isinf` in C and
+ *  Objective-C, and `simd::isinf` in C++.                                    */
+static inline SIMD_CFUNC simd_long3 __tg_isinf(simd_double3 x);
+/*! @abstract Do not call this function; instead use `isinf` in C and
+ *  Objective-C, and `simd::isinf` in C++.                                    */
+static inline SIMD_CFUNC simd_long4 __tg_isinf(simd_double4 x);
+/*! @abstract Do not call this function; instead use `isinf` in C and
+ *  Objective-C, and `simd::isinf` in C++.                                    */
+static inline SIMD_CFUNC simd_long8 __tg_isinf(simd_double8 x);
+
+/*! @abstract Do not call this function; instead use `isnan` in C and
+ *  Objective-C, and `simd::isnan` in C++.                                    */
+static inline SIMD_CFUNC simd_int2 __tg_isnan(simd_float2 x);
+/*! @abstract Do not call this function; instead use `isnan` in C and
+ *  Objective-C, and `simd::isnan` in C++.                                    */
+static inline SIMD_CFUNC simd_int3 __tg_isnan(simd_float3 x);
+/*! @abstract Do not call this function; instead use `isnan` in C and
+ *  Objective-C, and `simd::isnan` in C++.                                    */
+static inline SIMD_CFUNC simd_int4 __tg_isnan(simd_float4 x);
+/*! @abstract Do not call this function; instead use `isnan` in C and
+ *  Objective-C, and `simd::isnan` in C++.                                    */
+static inline SIMD_CFUNC simd_int8 __tg_isnan(simd_float8 x);
+/*! @abstract Do not call this function; instead use `isnan` in C and
+ *  Objective-C, and `simd::isnan` in C++.                                    */
+static inline SIMD_CFUNC simd_int16 __tg_isnan(simd_float16 x);
+/*! @abstract Do not call this function; instead use `isnan` in C and
+ *  Objective-C, and `simd::isnan` in C++.                                    */
+static inline SIMD_CFUNC simd_long2 __tg_isnan(simd_double2 x);
+/*! @abstract Do not call this function; instead use `isnan` in C and
+ *  Objective-C, and `simd::isnan` in C++.                                    */
+static inline SIMD_CFUNC simd_long3 __tg_isnan(simd_double3 x);
+/*! @abstract Do not call this function; instead use `isnan` in C and
+ *  Objective-C, and `simd::isnan` in C++.                                    */
+static inline SIMD_CFUNC simd_long4 __tg_isnan(simd_double4 x);
+/*! @abstract Do not call this function; instead use `isnan` in C and
+ *  Objective-C, and `simd::isnan` in C++.                                    */
+static inline SIMD_CFUNC simd_long8 __tg_isnan(simd_double8 x);
+
+/*! @abstract Do not call this function; instead use `isnormal` in C and
+ *  Objective-C, and `simd::isnormal` in C++.                                 */
+static inline SIMD_CFUNC simd_int2 __tg_isnormal(simd_float2 x);
+/*! @abstract Do not call this function; instead use `isnormal` in C and
+ *  Objective-C, and `simd::isnormal` in C++.                                 */
+static inline SIMD_CFUNC simd_int3 __tg_isnormal(simd_float3 x);
+/*! @abstract Do not call this function; instead use `isnormal` in C and
+ *  Objective-C, and `simd::isnormal` in C++.                                 */
+static inline SIMD_CFUNC simd_int4 __tg_isnormal(simd_float4 x);
+/*! @abstract Do not call this function; instead use `isnormal` in C and
+ *  Objective-C, and `simd::isnormal` in C++.                                 */
+static inline SIMD_CFUNC simd_int8 __tg_isnormal(simd_float8 x);
+/*! @abstract Do not call this function; instead use `isnormal` in C and
+ *  Objective-C, and `simd::isnormal` in C++.                                 */
+static inline SIMD_CFUNC simd_int16 __tg_isnormal(simd_float16 x);
+/*! @abstract Do not call this function; instead use `isnormal` in C and
+ *  Objective-C, and `simd::isnormal` in C++.                                 */
+static inline SIMD_CFUNC simd_long2 __tg_isnormal(simd_double2 x);
+/*! @abstract Do not call this function; instead use `isnormal` in C and
+ *  Objective-C, and `simd::isnormal` in C++.                                 */
+static inline SIMD_CFUNC simd_long3 __tg_isnormal(simd_double3 x);
+/*! @abstract Do not call this function; instead use `isnormal` in C and
+ *  Objective-C, and `simd::isnormal` in C++.                                 */
+static inline SIMD_CFUNC simd_long4 __tg_isnormal(simd_double4 x);
+/*! @abstract Do not call this function; instead use `isnormal` in C and
+ *  Objective-C, and `simd::isnormal` in C++.                                 */
+static inline SIMD_CFUNC simd_long8 __tg_isnormal(simd_double8 x);
+
+
 /*! @abstract Do not call this function; instead use `atan2` in C and
  *  Objective-C, and `simd::atan2` in C++.                                    */
 static inline SIMD_CFUNC simd_float2 __tg_atan2(simd_float2 y, simd_float2 x);
@@ -1402,189 +1602,225 @@ static inline SIMD_CFUNC simd_double8 simd_muladd(simd_double8 x, simd_double8 y
 
 #include <cmath>
 /*! @abstract Do not call this function directly; use simd::acos instead.     */
-static SIMD_CPPFUNC float __tg_acos(float x) { return ::acos(x); }
+static SIMD_CPPFUNC float __tg_acos(float x) { return ::acosf(x); }
 /*! @abstract Do not call this function directly; use simd::acos instead.     */
 static SIMD_CPPFUNC double __tg_acos(double x) { return ::acos(x); }
 /*! @abstract Do not call this function directly; use simd::asin instead.     */
-static SIMD_CPPFUNC float __tg_asin(float x) { return ::asin(x); }
+static SIMD_CPPFUNC float __tg_asin(float x) { return ::asinf(x); }
 /*! @abstract Do not call this function directly; use simd::asin instead.     */
 static SIMD_CPPFUNC double __tg_asin(double x) { return ::asin(x); }
 /*! @abstract Do not call this function directly; use simd::atan instead.     */
-static SIMD_CPPFUNC float __tg_atan(float x) { return ::atan(x); }
+static SIMD_CPPFUNC float __tg_atan(float x) { return ::atanf(x); }
 /*! @abstract Do not call this function directly; use simd::atan instead.     */
 static SIMD_CPPFUNC double __tg_atan(double x) { return ::atan(x); }
 /*! @abstract Do not call this function directly; use simd::cos instead.      */
-static SIMD_CPPFUNC float __tg_cos(float x) { return ::cos(x); }
+static SIMD_CPPFUNC float __tg_cos(float x) { return ::cosf(x); }
 /*! @abstract Do not call this function directly; use simd::cos instead.      */
 static SIMD_CPPFUNC double __tg_cos(double x) { return ::cos(x); }
 /*! @abstract Do not call this function directly; use simd::sin instead.      */
-static SIMD_CPPFUNC float __tg_sin(float x) { return ::sin(x); }
+static SIMD_CPPFUNC float __tg_sin(float x) { return ::sinf(x); }
 /*! @abstract Do not call this function directly; use simd::sin instead.      */
 static SIMD_CPPFUNC double __tg_sin(double x) { return ::sin(x); }
 /*! @abstract Do not call this function directly; use simd::tan instead.      */
-static SIMD_CPPFUNC float __tg_tan(float x) { return ::tan(x); }
+static SIMD_CPPFUNC float __tg_tan(float x) { return ::tanf(x); }
 /*! @abstract Do not call this function directly; use simd::tan instead.      */
 static SIMD_CPPFUNC double __tg_tan(double x) { return ::tan(x); }
 /*! @abstract Do not call this function directly; use simd::cospi instead.    */
-static SIMD_CPPFUNC float __tg_cospi(float x) { return ::__cospi(x); }
+static SIMD_CPPFUNC float __tg_cospi(float x) { return ::__cospif(x); }
 /*! @abstract Do not call this function directly; use simd::cospi instead.    */
 static SIMD_CPPFUNC double __tg_cospi(double x) { return ::__cospi(x); }
 /*! @abstract Do not call this function directly; use simd::sinpi instead.    */
-static SIMD_CPPFUNC float __tg_sinpi(float x) { return ::__sinpi(x); }
+static SIMD_CPPFUNC float __tg_sinpi(float x) { return ::__sinpif(x); }
 /*! @abstract Do not call this function directly; use simd::sinpi instead.    */
 static SIMD_CPPFUNC double __tg_sinpi(double x) { return ::__sinpi(x); }
 /*! @abstract Do not call this function directly; use simd::tanpi instead.    */
-static SIMD_CPPFUNC float __tg_tanpi(float x) { return ::__tanpi(x); }
+static SIMD_CPPFUNC float __tg_tanpi(float x) { return ::__tanpif(x); }
 /*! @abstract Do not call this function directly; use simd::tanpi instead.    */
 static SIMD_CPPFUNC double __tg_tanpi(double x) { return ::__tanpi(x); }
 /*! @abstract Do not call this function directly; use simd::acosh instead.    */
-static SIMD_CPPFUNC float __tg_acosh(float x) { return ::acosh(x); }
+static SIMD_CPPFUNC float __tg_acosh(float x) { return ::acoshf(x); }
 /*! @abstract Do not call this function directly; use simd::acosh instead.    */
 static SIMD_CPPFUNC double __tg_acosh(double x) { return ::acosh(x); }
 /*! @abstract Do not call this function directly; use simd::asinh instead.    */
-static SIMD_CPPFUNC float __tg_asinh(float x) { return ::asinh(x); }
+static SIMD_CPPFUNC float __tg_asinh(float x) { return ::asinhf(x); }
 /*! @abstract Do not call this function directly; use simd::asinh instead.    */
 static SIMD_CPPFUNC double __tg_asinh(double x) { return ::asinh(x); }
 /*! @abstract Do not call this function directly; use simd::atanh instead.    */
-static SIMD_CPPFUNC float __tg_atanh(float x) { return ::atanh(x); }
+static SIMD_CPPFUNC float __tg_atanh(float x) { return ::atanhf(x); }
 /*! @abstract Do not call this function directly; use simd::atanh instead.    */
 static SIMD_CPPFUNC double __tg_atanh(double x) { return ::atanh(x); }
 /*! @abstract Do not call this function directly; use simd::cosh instead.     */
-static SIMD_CPPFUNC float __tg_cosh(float x) { return ::cosh(x); }
+static SIMD_CPPFUNC float __tg_cosh(float x) { return ::coshf(x); }
 /*! @abstract Do not call this function directly; use simd::cosh instead.     */
 static SIMD_CPPFUNC double __tg_cosh(double x) { return ::cosh(x); }
 /*! @abstract Do not call this function directly; use simd::sinh instead.     */
-static SIMD_CPPFUNC float __tg_sinh(float x) { return ::sinh(x); }
+static SIMD_CPPFUNC float __tg_sinh(float x) { return ::sinhf(x); }
 /*! @abstract Do not call this function directly; use simd::sinh instead.     */
 static SIMD_CPPFUNC double __tg_sinh(double x) { return ::sinh(x); }
 /*! @abstract Do not call this function directly; use simd::tanh instead.     */
-static SIMD_CPPFUNC float __tg_tanh(float x) { return ::tanh(x); }
+static SIMD_CPPFUNC float __tg_tanh(float x) { return ::tanhf(x); }
 /*! @abstract Do not call this function directly; use simd::tanh instead.     */
 static SIMD_CPPFUNC double __tg_tanh(double x) { return ::tanh(x); }
 /*! @abstract Do not call this function directly; use simd::exp instead.      */
-static SIMD_CPPFUNC float __tg_exp(float x) { return ::exp(x); }
+static SIMD_CPPFUNC float __tg_exp(float x) { return ::expf(x); }
 /*! @abstract Do not call this function directly; use simd::exp instead.      */
 static SIMD_CPPFUNC double __tg_exp(double x) { return ::exp(x); }
 /*! @abstract Do not call this function directly; use simd::exp2 instead.     */
-static SIMD_CPPFUNC float __tg_exp2(float x) { return ::exp2(x); }
+static SIMD_CPPFUNC float __tg_exp2(float x) { return ::exp2f(x); }
 /*! @abstract Do not call this function directly; use simd::exp2 instead.     */
 static SIMD_CPPFUNC double __tg_exp2(double x) { return ::exp2(x); }
 /*! @abstract Do not call this function directly; use simd::exp10 instead.    */
-static SIMD_CPPFUNC float __tg_exp10(float x) { return ::__exp10(x); }
+static SIMD_CPPFUNC float __tg_exp10(float x) { return ::__exp10f(x); }
 /*! @abstract Do not call this function directly; use simd::exp10 instead.    */
 static SIMD_CPPFUNC double __tg_exp10(double x) { return ::__exp10(x); }
 /*! @abstract Do not call this function directly; use simd::expm1 instead.    */
-static SIMD_CPPFUNC float __tg_expm1(float x) { return ::expm1(x); }
+static SIMD_CPPFUNC float __tg_expm1(float x) { return ::expm1f(x); }
 /*! @abstract Do not call this function directly; use simd::expm1 instead.    */
 static SIMD_CPPFUNC double __tg_expm1(double x) { return ::expm1(x); }
 /*! @abstract Do not call this function directly; use simd::log instead.      */
-static SIMD_CPPFUNC float __tg_log(float x) { return ::log(x); }
+static SIMD_CPPFUNC float __tg_log(float x) { return ::logf(x); }
 /*! @abstract Do not call this function directly; use simd::log instead.      */
 static SIMD_CPPFUNC double __tg_log(double x) { return ::log(x); }
 /*! @abstract Do not call this function directly; use simd::log2 instead.     */
-static SIMD_CPPFUNC float __tg_log2(float x) { return ::log2(x); }
+static SIMD_CPPFUNC float __tg_log2(float x) { return ::log2f(x); }
 /*! @abstract Do not call this function directly; use simd::log2 instead.     */
 static SIMD_CPPFUNC double __tg_log2(double x) { return ::log2(x); }
 /*! @abstract Do not call this function directly; use simd::log10 instead.    */
-static SIMD_CPPFUNC float __tg_log10(float x) { return ::log10(x); }
+static SIMD_CPPFUNC float __tg_log10(float x) { return ::log10f(x); }
 /*! @abstract Do not call this function directly; use simd::log10 instead.    */
 static SIMD_CPPFUNC double __tg_log10(double x) { return ::log10(x); }
 /*! @abstract Do not call this function directly; use simd::log1p instead.    */
-static SIMD_CPPFUNC float __tg_log1p(float x) { return ::log1p(x); }
+static SIMD_CPPFUNC float __tg_log1p(float x) { return ::log1pf(x); }
 /*! @abstract Do not call this function directly; use simd::log1p instead.    */
 static SIMD_CPPFUNC double __tg_log1p(double x) { return ::log1p(x); }
 /*! @abstract Do not call this function directly; use simd::fabs instead.     */
-static SIMD_CPPFUNC float __tg_fabs(float x) { return ::fabs(x); }
+static SIMD_CPPFUNC float __tg_fabs(float x) { return ::fabsf(x); }
 /*! @abstract Do not call this function directly; use simd::fabs instead.     */
 static SIMD_CPPFUNC double __tg_fabs(double x) { return ::fabs(x); }
 /*! @abstract Do not call this function directly; use simd::cbrt instead.     */
-static SIMD_CPPFUNC float __tg_cbrt(float x) { return ::cbrt(x); }
+static SIMD_CPPFUNC float __tg_cbrt(float x) { return ::cbrtf(x); }
 /*! @abstract Do not call this function directly; use simd::cbrt instead.     */
 static SIMD_CPPFUNC double __tg_cbrt(double x) { return ::cbrt(x); }
 /*! @abstract Do not call this function directly; use simd::sqrt instead.     */
-static SIMD_CPPFUNC float __tg_sqrt(float x) { return ::sqrt(x); }
+static SIMD_CPPFUNC float __tg_sqrt(float x) { return ::sqrtf(x); }
 /*! @abstract Do not call this function directly; use simd::sqrt instead.     */
 static SIMD_CPPFUNC double __tg_sqrt(double x) { return ::sqrt(x); }
 /*! @abstract Do not call this function directly; use simd::erf instead.      */
-static SIMD_CPPFUNC float __tg_erf(float x) { return ::erf(x); }
+static SIMD_CPPFUNC float __tg_erf(float x) { return ::erff(x); }
 /*! @abstract Do not call this function directly; use simd::erf instead.      */
 static SIMD_CPPFUNC double __tg_erf(double x) { return ::erf(x); }
 /*! @abstract Do not call this function directly; use simd::erfc instead.     */
-static SIMD_CPPFUNC float __tg_erfc(float x) { return ::erfc(x); }
+static SIMD_CPPFUNC float __tg_erfc(float x) { return ::erfcf(x); }
 /*! @abstract Do not call this function directly; use simd::erfc instead.     */
 static SIMD_CPPFUNC double __tg_erfc(double x) { return ::erfc(x); }
 /*! @abstract Do not call this function directly; use simd::tgamma instead.   */
-static SIMD_CPPFUNC float __tg_tgamma(float x) { return ::tgamma(x); }
+static SIMD_CPPFUNC float __tg_tgamma(float x) { return ::tgammaf(x); }
 /*! @abstract Do not call this function directly; use simd::tgamma instead.   */
 static SIMD_CPPFUNC double __tg_tgamma(double x) { return ::tgamma(x); }
+/*! @abstract Do not call this function directly; use simd::lgamma instead.   */
+static SIMD_CPPFUNC float __tg_lgamma(float x) { return ::lgammaf(x); }
+/*! @abstract Do not call this function directly; use simd::lgamma instead.   */
+static SIMD_CPPFUNC double __tg_lgamma(double x) { return ::lgamma(x); }
 /*! @abstract Do not call this function directly; use simd::ceil instead.     */
-static SIMD_CPPFUNC float __tg_ceil(float x) { return ::ceil(x); }
+static SIMD_CPPFUNC float __tg_ceil(float x) { return ::ceilf(x); }
 /*! @abstract Do not call this function directly; use simd::ceil instead.     */
 static SIMD_CPPFUNC double __tg_ceil(double x) { return ::ceil(x); }
 /*! @abstract Do not call this function directly; use simd::floor instead.    */
-static SIMD_CPPFUNC float __tg_floor(float x) { return ::floor(x); }
+static SIMD_CPPFUNC float __tg_floor(float x) { return ::floorf(x); }
 /*! @abstract Do not call this function directly; use simd::floor instead.    */
 static SIMD_CPPFUNC double __tg_floor(double x) { return ::floor(x); }
 /*! @abstract Do not call this function directly; use simd::rint instead.     */
-static SIMD_CPPFUNC float __tg_rint(float x) { return ::rint(x); }
+static SIMD_CPPFUNC float __tg_rint(float x) { return ::rintf(x); }
 /*! @abstract Do not call this function directly; use simd::rint instead.     */
 static SIMD_CPPFUNC double __tg_rint(double x) { return ::rint(x); }
 /*! @abstract Do not call this function directly; use simd::round instead.    */
-static SIMD_CPPFUNC float __tg_round(float x) { return ::round(x); }
+static SIMD_CPPFUNC float __tg_round(float x) { return ::roundf(x); }
 /*! @abstract Do not call this function directly; use simd::round instead.    */
 static SIMD_CPPFUNC double __tg_round(double x) { return ::round(x); }
 /*! @abstract Do not call this function directly; use simd::trunc instead.    */
-static SIMD_CPPFUNC float __tg_trunc(float x) { return ::trunc(x); }
+static SIMD_CPPFUNC float __tg_trunc(float x) { return ::truncf(x); }
 /*! @abstract Do not call this function directly; use simd::trunc instead.    */
 static SIMD_CPPFUNC double __tg_trunc(double x) { return ::trunc(x); }
+#if SIMD_LIBRARY_VERSION >= 5
+/*! @abstract Do not call this function directly; use simd::sincos instead.   */
+static SIMD_INLINE SIMD_NODEBUG void __tg_sincos(float x, float *sinp, float *cosp) { ::__sincosf(x, sinp, cosp); }
+/*! @abstract Do not call this function directly; use simd::sincos instead.   */
+static SIMD_INLINE SIMD_NODEBUG void __tg_sincos(double x, double *sinp, double *cosp) { ::__sincos(x, sinp, cosp); }
+/*! @abstract Do not call this function directly; use simd::sincospi
+ *  instead.                                                                  */
+static SIMD_INLINE SIMD_NODEBUG void __tg_sincospi(float x, float *sinp, float *cosp) { ::__sincospif(x, sinp, cosp); }
+/*! @abstract Do not call this function directly; use simd::sincospi
+ *  instead.                                                                  */
+static SIMD_INLINE SIMD_NODEBUG void __tg_sincospi(double x, double *sinp, double *cosp) { ::__sincospi(x, sinp, cosp); }
+#endif
+/*! @abstract Do not call this function directly; use simd::isfinite
+ *  instead.                                                                  */
+static SIMD_CPPFUNC float __tg_isfinite(float x) { return ::isfinite(x); }
+/*! @abstract Do not call this function directly; use simd::isfinite
+ *  instead.                                                                  */
+static SIMD_CPPFUNC double __tg_isfinite(double x) { return ::isfinite(x); }
+/*! @abstract Do not call this function directly; use simd::isinf instead.    */
+static SIMD_CPPFUNC float __tg_isinf(float x) { return ::isinf(x); }
+/*! @abstract Do not call this function directly; use simd::isinf instead.    */
+static SIMD_CPPFUNC double __tg_isinf(double x) { return ::isinf(x); }
+/*! @abstract Do not call this function directly; use simd::isnan instead.    */
+static SIMD_CPPFUNC float __tg_isnan(float x) { return ::isnan(x); }
+/*! @abstract Do not call this function directly; use simd::isnan instead.    */
+static SIMD_CPPFUNC double __tg_isnan(double x) { return ::isnan(x); }
+/*! @abstract Do not call this function directly; use simd::isnormal
+ *  instead.                                                                  */
+static SIMD_CPPFUNC float __tg_isnormal(float x) { return ::isnormal(x); }
+/*! @abstract Do not call this function directly; use simd::isnormal
+ *  instead.                                                                  */
+static SIMD_CPPFUNC double __tg_isnormal(double x) { return ::isnormal(x); }
 /*! @abstract Do not call this function directly; use simd::atan2 instead.    */
-static SIMD_CPPFUNC float __tg_atan2(float x, float y) { return ::atan2(x, y); }
+static SIMD_CPPFUNC float __tg_atan2(float x, float y) { return ::atan2f(x, y); }
 /*! @abstract Do not call this function directly; use simd::atan2 instead.    */
-static SIMD_CPPFUNC double __tg_atan2(double x, float y) { return ::atan2(x, y); }
+static SIMD_CPPFUNC double __tg_atan2(double x, double y) { return ::atan2(x, y); }
 /*! @abstract Do not call this function directly; use simd::hypot instead.    */
-static SIMD_CPPFUNC float __tg_hypot(float x, float y) { return ::hypot(x, y); }
+static SIMD_CPPFUNC float __tg_hypot(float x, float y) { return ::hypotf(x, y); }
 /*! @abstract Do not call this function directly; use simd::hypot instead.    */
-static SIMD_CPPFUNC double __tg_hypot(double x, float y) { return ::hypot(x, y); }
+static SIMD_CPPFUNC double __tg_hypot(double x, double y) { return ::hypot(x, y); }
 /*! @abstract Do not call this function directly; use simd::pow instead.      */
-static SIMD_CPPFUNC float __tg_pow(float x, float y) { return ::pow(x, y); }
+static SIMD_CPPFUNC float __tg_pow(float x, float y) { return ::powf(x, y); }
 /*! @abstract Do not call this function directly; use simd::pow instead.      */
-static SIMD_CPPFUNC double __tg_pow(double x, float y) { return ::pow(x, y); }
+static SIMD_CPPFUNC double __tg_pow(double x, double y) { return ::pow(x, y); }
 /*! @abstract Do not call this function directly; use simd::fmod instead.     */
-static SIMD_CPPFUNC float __tg_fmod(float x, float y) { return ::fmod(x, y); }
+static SIMD_CPPFUNC float __tg_fmod(float x, float y) { return ::fmodf(x, y); }
 /*! @abstract Do not call this function directly; use simd::fmod instead.     */
-static SIMD_CPPFUNC double __tg_fmod(double x, float y) { return ::fmod(x, y); }
+static SIMD_CPPFUNC double __tg_fmod(double x, double y) { return ::fmod(x, y); }
 /*! @abstract Do not call this function directly; use simd::remainder
  *  instead.                                                                  */
-static SIMD_CPPFUNC float __tg_remainder(float x, float y) { return ::remainder(x, y); }
+static SIMD_CPPFUNC float __tg_remainder(float x, float y) { return ::remainderf(x, y); }
 /*! @abstract Do not call this function directly; use simd::remainder
  *  instead.                                                                  */
-static SIMD_CPPFUNC double __tg_remainder(double x, float y) { return ::remainder(x, y); }
+static SIMD_CPPFUNC double __tg_remainder(double x, double y) { return ::remainder(x, y); }
 /*! @abstract Do not call this function directly; use simd::copysign
  *  instead.                                                                  */
-static SIMD_CPPFUNC float __tg_copysign(float x, float y) { return ::copysign(x, y); }
+static SIMD_CPPFUNC float __tg_copysign(float x, float y) { return ::copysignf(x, y); }
 /*! @abstract Do not call this function directly; use simd::copysign
  *  instead.                                                                  */
-static SIMD_CPPFUNC double __tg_copysign(double x, float y) { return ::copysign(x, y); }
+static SIMD_CPPFUNC double __tg_copysign(double x, double y) { return ::copysign(x, y); }
 /*! @abstract Do not call this function directly; use simd::nextafter
  *  instead.                                                                  */
-static SIMD_CPPFUNC float __tg_nextafter(float x, float y) { return ::nextafter(x, y); }
+static SIMD_CPPFUNC float __tg_nextafter(float x, float y) { return ::nextafterf(x, y); }
 /*! @abstract Do not call this function directly; use simd::nextafter
  *  instead.                                                                  */
-static SIMD_CPPFUNC double __tg_nextafter(double x, float y) { return ::nextafter(x, y); }
+static SIMD_CPPFUNC double __tg_nextafter(double x, double y) { return ::nextafter(x, y); }
 /*! @abstract Do not call this function directly; use simd::fdim instead.     */
-static SIMD_CPPFUNC float __tg_fdim(float x, float y) { return ::fdim(x, y); }
+static SIMD_CPPFUNC float __tg_fdim(float x, float y) { return ::fdimf(x, y); }
 /*! @abstract Do not call this function directly; use simd::fdim instead.     */
-static SIMD_CPPFUNC double __tg_fdim(double x, float y) { return ::fdim(x, y); }
+static SIMD_CPPFUNC double __tg_fdim(double x, double y) { return ::fdim(x, y); }
 /*! @abstract Do not call this function directly; use simd::fmax instead.     */
-static SIMD_CPPFUNC float __tg_fmax(float x, float y) { return ::fmax(x, y); }
+static SIMD_CPPFUNC float __tg_fmax(float x, float y) { return ::fmaxf(x, y); }
 /*! @abstract Do not call this function directly; use simd::fmax instead.     */
-static SIMD_CPPFUNC double __tg_fmax(double x, float y) { return ::fmax(x, y); }
+static SIMD_CPPFUNC double __tg_fmax(double x, double y) { return ::fmax(x, y); }
 /*! @abstract Do not call this function directly; use simd::fmin instead.     */
-static SIMD_CPPFUNC float __tg_fmin(float x, float y) { return ::fmin(x, y); }
+static SIMD_CPPFUNC float __tg_fmin(float x, float y) { return ::fminf(x, y); }
 /*! @abstract Do not call this function directly; use simd::fmin instead.     */
-static SIMD_CPPFUNC double __tg_fmin(double x, float y) { return ::fmin(x, y); }
+static SIMD_CPPFUNC double __tg_fmin(double x, double y) { return ::fmin(x, y); }
 /*! @abstract Do not call this function directly; use simd::fma instead.      */
-static SIMD_CPPFUNC float __tg_fma(float x, float y, float z) { return ::fma(x, y, z); }
+static SIMD_CPPFUNC float __tg_fma(float x, float y, float z) { return ::fmaf(x, y, z); }
 /*! @abstract Do not call this function directly; use simd::fma instead.      */
 static SIMD_CPPFUNC double __tg_fma(double x, double y, double z) { return ::fma(x, y, z); }
   
@@ -1742,6 +1978,11 @@ namespace simd {
   template <typename fptypeN>
   static SIMD_CPPFUNC fptypeN tgamma(fptypeN x) { return ::__tg_tgamma(x); }
   
+/*! @abstract Generalizes the <cmath> function lgamma to operate on vectors
+ *  of floats and doubles.                                                    */
+  template <typename fptypeN>
+  static SIMD_CPPFUNC fptypeN lgamma(fptypeN x) { return ::__tg_lgamma(x); }
+  
 /*! @abstract Generalizes the <cmath> function ceil to operate on vectors of
  *  floats and doubles.                                                       */
   template <typename fptypeN>
@@ -1767,6 +2008,44 @@ namespace simd {
   template <typename fptypeN>
   static SIMD_CPPFUNC fptypeN trunc(fptypeN x) { return ::__tg_trunc(x); }
   
+#if SIMD_LIBRARY_VERSION >= 5
+/*! @abstract Computes sincos more efficiently than separate computations.    */
+  template <typename fptypeN>
+  static SIMD_INLINE SIMD_NODEBUG void sincos(fptypeN x, fptypeN *sinp, fptypeN *cosp) { ::__tg_sincos(x, sinp, cosp); }
+
+/*! @abstract Computes sincospi more efficiently than separate computations.  */
+  template <typename fptypeN>
+  static SIMD_INLINE SIMD_NODEBUG void sincospi(fptypeN x, fptypeN *sinp, fptypeN *cosp) { ::__tg_sincospi(x, sinp, cosp); }
+
+#endif
+/*! @abstract Generalizes the <cmath> function isfinite to operate on
+ *  vectors of floats and doubles.                                            */
+  template <typename fptypeN>
+  static SIMD_CPPFUNC
+  typename std::enable_if<std::is_floating_point<typename traits<fptypeN>::scalar_t>::value, typename traits<fptypeN>::mask_t>::type
+  isfinite(fptypeN x) { return ::__tg_isfinite(x); }
+
+/*! @abstract Generalizes the <cmath> function isinf to operate on vectors
+ *  of floats and doubles.                                                    */
+  template <typename fptypeN>
+  static SIMD_CPPFUNC
+  typename std::enable_if<std::is_floating_point<typename traits<fptypeN>::scalar_t>::value, typename traits<fptypeN>::mask_t>::type
+  isinf(fptypeN x) { return ::__tg_isinf(x); }
+
+/*! @abstract Generalizes the <cmath> function isnan to operate on vectors
+ *  of floats and doubles.                                                    */
+  template <typename fptypeN>
+  static SIMD_CPPFUNC
+  typename std::enable_if<std::is_floating_point<typename traits<fptypeN>::scalar_t>::value, typename traits<fptypeN>::mask_t>::type
+  isnan(fptypeN x) { return ::__tg_isnan(x); }
+
+/*! @abstract Generalizes the <cmath> function isnormal to operate on
+ *  vectors of floats and doubles.                                            */
+  template <typename fptypeN>
+  static SIMD_CPPFUNC
+  typename std::enable_if<std::is_floating_point<typename traits<fptypeN>::scalar_t>::value, typename traits<fptypeN>::mask_t>::type
+  isnormal(fptypeN x) { return ::__tg_isnormal(x); }
+
 /*! @abstract Generalizes the <cmath> function atan2 to operate on vectors
  *  of floats and doubles.                                                    */
   template <typename fptypeN>
@@ -1876,6 +2155,26 @@ static inline SIMD_CFUNC double __tg_tanpi(double x) { return __tanpi(x); }
  *  floats and doubles as provided by `<simd/simd.h>`.                        */
 #define tanpi(__x) __tg_tanpi(__tg_promote1((__x))(__x))
 
+#if SIMD_LIBRARY_VERSION >= 5
+static inline SIMD_NONCONST void __tg_sincos(float x, float *sinp, float *cosp) { __sincosf(x, sinp, cosp); }
+static inline SIMD_NONCONST void __tg_sincos(double x, double *sinp, double *cosp) { __sincos(x, sinp, cosp); }
+#undef sincos
+/*! @abstract `sincos(x)` computes `sin(x)` and `cos(x)` more efficiently.
+ *
+ *  @discussion Defined for `float` and `double` as well as vectors of
+ *  floats and doubles as provided by `<simd/simd.h>`.                        */
+#define sincos(__x, __sinp, __cosp) __tg_sincos(__tg_promote1((__x))(__x), __sinp, __cosp)
+
+static inline SIMD_NONCONST void __tg_sincospi(float x, float *sinp, float *cosp) { __sincospif(x, sinp, cosp); }
+static inline SIMD_NONCONST void __tg_sincospi(double x, double *sinp, double *cosp) { __sincospi(x, sinp, cosp); }
+#undef sincospi
+/*! @abstract `sincospi(x)` computes `sin(pi * x)` and `cos(pi * x)` more efficiently.
+ *
+ *  @discussion Defined for `float` and `double` as well as vectors of
+ *  floats and doubles as provided by `<simd/simd.h>`.                        */
+#define sincospi(__x, __sinp, __cosp) __tg_sincospi(__tg_promote1((__x))(__x), __sinp, __cosp)
+#endif // SIMD_LIBRARY_VERSION >= 5
+
 static inline SIMD_CFUNC float __tg_exp10(float x) { return __exp10f(x); }
 static inline SIMD_CFUNC double __tg_exp10(double x) { return __exp10(x); }
 #undef exp10
@@ -1886,7 +2185,90 @@ static inline SIMD_CFUNC double __tg_exp10(double x) { return __exp10(x); }
  *  and doubles as provided by `<simd/simd.h>`.                               */
 #define exp10(__x) __tg_exp10(__tg_promote1((__x))(__x))
 #endif
-  
+
+#if (defined(__GNUC__) && 0 == __FINITE_MATH_ONLY__)
+static inline SIMD_CFUNC int __tg_isfinite(float x) { return __inline_isfinitef(x); }
+static inline SIMD_CFUNC int __tg_isfinite(double x) { return __inline_isfinited(x); }
+static inline SIMD_CFUNC int __tg_isfinite(long double x) { return __inline_isfinitel(x); }
+#undef isfinite
+/*! @abstract `__tg_isfinite(x)` determines if x is a finite value.
+ *
+ *  @discussion Defined for `float`, `double` and `long double` as well as vectors of floats
+ *  and doubles as provided by `<simd/simd.h>`.                               */
+#define isfinite(__x) __tg_isfinite(__tg_promote1((__x))(__x))
+
+static inline SIMD_CFUNC int __tg_isinf(float x) { return __inline_isinff(x); }
+static inline SIMD_CFUNC int __tg_isinf(double x) { return __inline_isinfd(x); }
+static inline SIMD_CFUNC int __tg_isinf(long double x) { return __inline_isinfl(x); }
+#undef isinf
+/*! @abstract `__tg_isinf(x)` determines if x is positive or negative infinity.
+ *
+ *  @discussion Defined for `float`, `double` and `long double` as well as vectors of floats
+ *  and doubles as provided by `<simd/simd.h>`.                               */
+#define isinf(__x) __tg_isinf(__tg_promote1((__x))(__x))
+
+static inline SIMD_CFUNC int __tg_isnan(float x) { return __inline_isnanf(x); }
+static inline SIMD_CFUNC int __tg_isnan(double x) { return __inline_isnand(x); }
+static inline SIMD_CFUNC int __tg_isnan(long double x) { return __inline_isnanl(x); }
+#undef isnan
+/*! @abstract `__tg_isnan(x)` determines if x is a not-a-number (NaN) value.
+ *
+ *  @discussion Defined for `float`, `double` and `long double` as well as vectors of floats
+ *  and doubles as provided by `<simd/simd.h>`.                               */
+#define isnan(__x) __tg_isnan(__tg_promote1((__x))(__x))
+
+static inline SIMD_CFUNC int __tg_isnormal(float x) { return __inline_isnormalf(x); }
+static inline SIMD_CFUNC int __tg_isnormal(double x) { return __inline_isnormald(x); }
+static inline SIMD_CFUNC int __tg_isnormal(long double x) { return __inline_isnormall(x); }
+#undef isnormal
+/*! @abstract `__tg_isnormal(x)` determines if x is a normal value.
+ *
+ *  @discussion Defined for `float`, `double` and `long double` as well as vectors of floats
+ *  and doubles as provided by `<simd/simd.h>`.                               */
+#define isnormal(__x) __tg_isnormal(__tg_promote1((__x))(__x))
+
+#else /* defined(__GNUC__) && 0 == __FINITE_MATH_ONLY__ */
+
+static inline SIMD_CFUNC int __tg_isfinite(float x) { return __isfinitef(x); }
+static inline SIMD_CFUNC int __tg_isfinite(double x) { return __isfinited(x); }
+static inline SIMD_CFUNC int __tg_isfinite(long double x) { return __isfinitel(x); }
+#undef isfinite
+/*! @abstract `__tg_isfinite(x)` determines if x is a finite value.
+ *
+ *  @discussion Defined for `float`, `double` and `long double` as well as vectors of floats
+ *  and doubles as provided by `<simd/simd.h>`.                               */
+#define isfinite(__x) __tg_isfinite(__tg_promote1((__x))(__x))
+
+static inline SIMD_CFUNC int __tg_isinf(float x) { return __isinff(x); }
+static inline SIMD_CFUNC int __tg_isinf(double x) { return __isinfd(x); }
+static inline SIMD_CFUNC int __tg_isinf(long double x) { return __isinfl(x); }
+#undef isinf
+/*! @abstract `__tg_isinf(x)` determines if x is positive or negative infinity.
+ *
+ *  @discussion Defined for `float`, `double` and `long double` as well as vectors of floats
+ *  and doubles as provided by `<simd/simd.h>`.                               */
+#define isinf(__x) __tg_isinf(__tg_promote1((__x))(__x))
+
+static inline SIMD_CFUNC int __tg_isnan(float x) { return __isnanf(x); }
+static inline SIMD_CFUNC int __tg_isnan(double x) { return __isnand(x); }
+static inline SIMD_CFUNC int __tg_isnan(long double x) { return __isnanl(x); }
+#undef isnan
+/*! @abstract `__tg_isnan(x)` determines if x is a not-a-number (NaN) value.
+ *
+ *  @discussion Defined for `float`, `double` and `long double` as well as vectors of floats
+ *  and doubles as provided by `<simd/simd.h>`.                               */
+#define isnan(__x) __tg_isnan(__tg_promote1((__x))(__x))
+
+static inline SIMD_CFUNC int __tg_isnormal(float x) { return __isnormalf(x); }
+static inline SIMD_CFUNC int __tg_isnormal(double x) { return __isnormald(x); }
+static inline SIMD_CFUNC int __tg_isnormal(long double x) { return __isnormall(x); }
+#undef isnormal
+/*! @abstract `__tg_isnormal(x)` determines if x is a normal value.
+ *
+ *  @discussion Defined for `float`, `double` and `long double` as well as vectors of floats
+ *  and doubles as provided by `<simd/simd.h>`.                               */
+#define isnormal(__x) __tg_isnormal(__tg_promote1((__x))(__x))
+#endif /* defined(__GNUC__) && 0 == __FINITE_MATH_ONLY__ */
 #endif /* !__cplusplus */
   
 #pragma mark - fabs implementation
@@ -1895,11 +2277,55 @@ static inline SIMD_CFUNC simd_float3 __tg_fabs(simd_float3 x) { return simd_bits
 static inline SIMD_CFUNC simd_float4 __tg_fabs(simd_float4 x) { return simd_bitselect(0.0, x, 0x7fffffff); }
 static inline SIMD_CFUNC simd_float8 __tg_fabs(simd_float8 x) { return simd_bitselect(0.0, x, 0x7fffffff); }
 static inline SIMD_CFUNC simd_float16 __tg_fabs(simd_float16 x) { return simd_bitselect(0.0, x, 0x7fffffff); }
-static inline SIMD_CFUNC simd_double2 __tg_fabs(simd_double2 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffffL); }
-static inline SIMD_CFUNC simd_double3 __tg_fabs(simd_double3 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffffL); }
-static inline SIMD_CFUNC simd_double4 __tg_fabs(simd_double4 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffffL); }
-static inline SIMD_CFUNC simd_double8 __tg_fabs(simd_double8 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffffL); }
+static inline SIMD_CFUNC simd_double2 __tg_fabs(simd_double2 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffff); }
+static inline SIMD_CFUNC simd_double3 __tg_fabs(simd_double3 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffff); }
+static inline SIMD_CFUNC simd_double4 __tg_fabs(simd_double4 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffff); }
+static inline SIMD_CFUNC simd_double8 __tg_fabs(simd_double8 x) { return simd_bitselect(0.0, x, 0x7fffffffffffffff); }
   
+#pragma mark - isfinite implementation
+static inline SIMD_CFUNC simd_int2 __tg_isfinite(simd_float2 x) { return x == x && __tg_fabs(x) != (simd_float2)INFINITY; }
+static inline SIMD_CFUNC simd_int3 __tg_isfinite(simd_float3 x) { return x == x && __tg_fabs(x) != (simd_float3)INFINITY; }
+static inline SIMD_CFUNC simd_int4 __tg_isfinite(simd_float4 x) { return x == x && __tg_fabs(x) != (simd_float4)INFINITY; }
+static inline SIMD_CFUNC simd_int8 __tg_isfinite(simd_float8 x) { return x == x && __tg_fabs(x) != (simd_float8)INFINITY; }
+static inline SIMD_CFUNC simd_int16 __tg_isfinite(simd_float16 x) { return x == x && __tg_fabs(x) != (simd_float16)INFINITY; }
+static inline SIMD_CFUNC simd_long2 __tg_isfinite(simd_double2 x) { return x == x && __tg_fabs(x) != (simd_double2)INFINITY; }
+static inline SIMD_CFUNC simd_long3 __tg_isfinite(simd_double3 x) { return x == x && __tg_fabs(x) != (simd_double3)INFINITY; }
+static inline SIMD_CFUNC simd_long4 __tg_isfinite(simd_double4 x) { return x == x && __tg_fabs(x) != (simd_double4)INFINITY; }
+static inline SIMD_CFUNC simd_long8 __tg_isfinite(simd_double8 x) { return x == x && __tg_fabs(x) != (simd_double8)INFINITY; }
+
+#pragma mark - isinf implementation
+static inline SIMD_CFUNC simd_int2 __tg_isinf(simd_float2 x) { return __tg_fabs(x) == (simd_float2)INFINITY; }
+static inline SIMD_CFUNC simd_int3 __tg_isinf(simd_float3 x) { return __tg_fabs(x) == (simd_float3)INFINITY; }
+static inline SIMD_CFUNC simd_int4 __tg_isinf(simd_float4 x) { return __tg_fabs(x) == (simd_float4)INFINITY; }
+static inline SIMD_CFUNC simd_int8 __tg_isinf(simd_float8 x) { return __tg_fabs(x) == (simd_float8)INFINITY; }
+static inline SIMD_CFUNC simd_int16 __tg_isinf(simd_float16 x) { return __tg_fabs(x) == (simd_float16)INFINITY; }
+static inline SIMD_CFUNC simd_long2 __tg_isinf(simd_double2 x) { return __tg_fabs(x) == (simd_double2)INFINITY; }
+static inline SIMD_CFUNC simd_long3 __tg_isinf(simd_double3 x) { return __tg_fabs(x) == (simd_double3)INFINITY; }
+static inline SIMD_CFUNC simd_long4 __tg_isinf(simd_double4 x) { return __tg_fabs(x) == (simd_double4)INFINITY; }
+static inline SIMD_CFUNC simd_long8 __tg_isinf(simd_double8 x) { return __tg_fabs(x) == (simd_double8)INFINITY; }
+
+#pragma mark - isnan implementation
+static inline SIMD_CFUNC simd_int2 __tg_isnan(simd_float2 x) { return x != x; }
+static inline SIMD_CFUNC simd_int3 __tg_isnan(simd_float3 x) { return x != x; }
+static inline SIMD_CFUNC simd_int4 __tg_isnan(simd_float4 x) { return x != x; }
+static inline SIMD_CFUNC simd_int8 __tg_isnan(simd_float8 x) { return x != x; }
+static inline SIMD_CFUNC simd_int16 __tg_isnan(simd_float16 x) { return x != x; }
+static inline SIMD_CFUNC simd_long2 __tg_isnan(simd_double2 x) { return x != x; }
+static inline SIMD_CFUNC simd_long3 __tg_isnan(simd_double3 x) { return x != x; }
+static inline SIMD_CFUNC simd_long4 __tg_isnan(simd_double4 x) { return x != x; }
+static inline SIMD_CFUNC simd_long8 __tg_isnan(simd_double8 x) { return x != x; }
+
+#pragma mark - isnormal implementation
+static inline SIMD_CFUNC simd_int2 __tg_isnormal(simd_float2 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_float2)__FLT_MIN__; }
+static inline SIMD_CFUNC simd_int3 __tg_isnormal(simd_float3 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_float3)__FLT_MIN__; }
+static inline SIMD_CFUNC simd_int4 __tg_isnormal(simd_float4 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_float4)__FLT_MIN__; }
+static inline SIMD_CFUNC simd_int8 __tg_isnormal(simd_float8 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_float8)__FLT_MIN__; }
+static inline SIMD_CFUNC simd_int16 __tg_isnormal(simd_float16 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_float16)__FLT_MIN__; }
+static inline SIMD_CFUNC simd_long2 __tg_isnormal(simd_double2 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_double2)__DBL_MIN__; }
+static inline SIMD_CFUNC simd_long3 __tg_isnormal(simd_double3 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_double3)__DBL_MIN__; }
+static inline SIMD_CFUNC simd_long4 __tg_isnormal(simd_double4 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_double4)__DBL_MIN__; }
+static inline SIMD_CFUNC simd_long8 __tg_isnormal(simd_double8 x) { return __tg_isfinite(x) && __tg_fabs(x) >= (simd_double8)__DBL_MIN__; }
+
 #pragma mark - fmin, fmax implementation
 static SIMD_CFUNC simd_float2 __tg_fmin(simd_float2 x, simd_float2 y) {
 #if defined __SSE2__
@@ -1946,11 +2372,11 @@ static SIMD_CFUNC simd_float8 __tg_fmin(simd_float8 x, simd_float8 y) {
 }
   
 static SIMD_CFUNC simd_float16 __tg_fmin(simd_float16 x, simd_float16 y) {
-#if defined __AVX512DQ__ && !__FINITE_MATH_ONLY__
+#if defined __x86_64__ && defined __AVX512DQ__ && !__FINITE_MATH_ONLY__
   return _mm512_range_ps(x, y, 4);
-#elif defined __AVX512F__ && __FINITE_MATH_ONLY__
+#elif defined __x86_64__ && defined __AVX512F__ && __FINITE_MATH_ONLY__
   return _mm512_min_ps(x, y);
-#elif defined __AVX512F__
+#elif defined __x86_64__ && defined __AVX512F__
   return simd_bitselect(_mm512_min_ps(x, y), x, y != y);
 #else
   return simd_make_float16(__tg_fmin(x.lo, y.lo), __tg_fmin(x.hi, y.hi));
@@ -1988,11 +2414,11 @@ static SIMD_CFUNC simd_double4 __tg_fmin(simd_double4 x, simd_double4 y) {
 }
 
 static SIMD_CFUNC simd_double8 __tg_fmin(simd_double8 x, simd_double8 y) {
-#if defined __AVX512DQ__
+#if defined __x86_64__ && defined __AVX512DQ__
   return _mm512_range_pd(x, y, 4);
-#elif defined __AVX512F__ && __FINITE_MATH_ONLY__
+#elif defined __x86_64__ && defined __AVX512F__ && __FINITE_MATH_ONLY__
   return _mm512_min_pd(x, y);
-#elif defined __AVX512F__
+#elif defined __x86_64__ && defined __AVX512F__
   return simd_bitselect(_mm512_min_pd(x, y), x, y != y);
 #else
   return simd_make_double8(__tg_fmin(x.lo, y.lo), __tg_fmin(x.hi, y.hi));
@@ -2044,11 +2470,11 @@ static SIMD_CFUNC simd_float8 __tg_fmax(simd_float8 x, simd_float8 y) {
 }
   
 static SIMD_CFUNC simd_float16 __tg_fmax(simd_float16 x, simd_float16 y) {
-#if defined __AVX512DQ__ && !__FINITE_MATH_ONLY__
+#if defined __x86_64__ && defined __AVX512DQ__ && !__FINITE_MATH_ONLY__
   return _mm512_range_ps(x, y, 5);
-#elif defined __AVX512F__ && __FINITE_MATH_ONLY__
+#elif defined __x86_64__ && defined __AVX512F__ && __FINITE_MATH_ONLY__
   return _mm512_max_ps(x, y);
-#elif defined __AVX512F__
+#elif defined __x86_64__ && defined __AVX512F__
   return simd_bitselect(_mm512_max_ps(x, y), x, y != y);
 #else
   return simd_make_float16(__tg_fmax(x.lo, y.lo), __tg_fmax(x.hi, y.hi));
@@ -2086,11 +2512,11 @@ static SIMD_CFUNC simd_double4 __tg_fmax(simd_double4 x, simd_double4 y) {
 }
 
 static SIMD_CFUNC simd_double8 __tg_fmax(simd_double8 x, simd_double8 y) {
-#if defined __AVX512DQ__
+#if defined __x86_64__ && defined __AVX512DQ__
   return _mm512_range_pd(x, y, 5);
-#elif defined __AVX512F__ && __FINITE_MATH_ONLY__
+#elif defined __x86_64__ && defined __AVX512F__ && __FINITE_MATH_ONLY__
   return _mm512_max_pd(x, y);
-#elif defined __AVX512F__
+#elif defined __x86_64__ && defined __AVX512F__
   return simd_bitselect(_mm512_max_pd(x, y), x, y != y);
 #else
   return simd_make_double8(__tg_fmax(x.lo, y.lo), __tg_fmax(x.hi, y.hi));
@@ -2103,10 +2529,10 @@ static inline SIMD_CFUNC simd_float3 __tg_copysign(simd_float3 x, simd_float3 y)
 static inline SIMD_CFUNC simd_float4 __tg_copysign(simd_float4 x, simd_float4 y) { return simd_bitselect(y, x, 0x7fffffff); }
 static inline SIMD_CFUNC simd_float8 __tg_copysign(simd_float8 x, simd_float8 y) { return simd_bitselect(y, x, 0x7fffffff); }
 static inline SIMD_CFUNC simd_float16 __tg_copysign(simd_float16 x, simd_float16 y) { return simd_bitselect(y, x, 0x7fffffff); }
-static inline SIMD_CFUNC simd_double2 __tg_copysign(simd_double2 x, simd_double2 y) { return simd_bitselect(y, x, 0x7fffffffffffffffL); }
-static inline SIMD_CFUNC simd_double3 __tg_copysign(simd_double3 x, simd_double3 y) { return simd_bitselect(y, x, 0x7fffffffffffffffL); }
-static inline SIMD_CFUNC simd_double4 __tg_copysign(simd_double4 x, simd_double4 y) { return simd_bitselect(y, x, 0x7fffffffffffffffL); }
-static inline SIMD_CFUNC simd_double8 __tg_copysign(simd_double8 x, simd_double8 y) { return simd_bitselect(y, x, 0x7fffffffffffffffL); }
+static inline SIMD_CFUNC simd_double2 __tg_copysign(simd_double2 x, simd_double2 y) { return simd_bitselect(y, x, 0x7fffffffffffffff); }
+static inline SIMD_CFUNC simd_double3 __tg_copysign(simd_double3 x, simd_double3 y) { return simd_bitselect(y, x, 0x7fffffffffffffff); }
+static inline SIMD_CFUNC simd_double4 __tg_copysign(simd_double4 x, simd_double4 y) { return simd_bitselect(y, x, 0x7fffffffffffffff); }
+static inline SIMD_CFUNC simd_double8 __tg_copysign(simd_double8 x, simd_double8 y) { return simd_bitselect(y, x, 0x7fffffffffffffff); }
   
 #pragma mark - sqrt implementation
 static SIMD_CFUNC simd_float2 __tg_sqrt(simd_float2 x) {
@@ -2142,7 +2568,7 @@ static SIMD_CFUNC simd_float8 __tg_sqrt(simd_float8 x) {
 }
   
 static SIMD_CFUNC simd_float16 __tg_sqrt(simd_float16 x) {
-#if defined __AVX512F__
+#if defined __x86_64__ && defined __AVX512F__
   return _mm512_sqrt_ps(x);
 #else
   return simd_make_float16(__tg_sqrt(x.lo), __tg_sqrt(x.hi));
@@ -2172,7 +2598,7 @@ static SIMD_CFUNC simd_double4 __tg_sqrt(simd_double4 x) {
 }
   
 static SIMD_CFUNC simd_double8 __tg_sqrt(simd_double8 x) {
-#if defined __AVX512F__
+#if defined __x86_64__ && defined __AVX512F__
   return _mm512_sqrt_pd(x);
 #else
   return simd_make_double8(__tg_sqrt(x.lo), __tg_sqrt(x.hi));
@@ -2219,7 +2645,7 @@ static SIMD_CFUNC simd_float8 __tg_ceil(simd_float8 x) {
 }
  
 static SIMD_CFUNC simd_float16 __tg_ceil(simd_float16 x) {
-#if defined __AVX512F__
+#if defined __x86_64__ && defined __AVX512F__
   return _mm512_roundscale_ps(x, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
 #else
   return simd_make_float16(__tg_ceil(x.lo), __tg_ceil(x.hi));
@@ -2257,7 +2683,7 @@ static SIMD_CFUNC simd_double4 __tg_ceil(simd_double4 x) {
 }
  
 static SIMD_CFUNC simd_double8 __tg_ceil(simd_double8 x) {
-#if defined __AVX512F__
+#if defined __x86_64__ && defined __AVX512F__
   return _mm512_roundscale_pd(x, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC);
 #else
   return simd_make_double8(__tg_ceil(x.lo), __tg_ceil(x.hi));
@@ -2303,7 +2729,7 @@ static SIMD_CFUNC simd_float8 __tg_floor(simd_float8 x) {
 }
  
 static SIMD_CFUNC simd_float16 __tg_floor(simd_float16 x) {
-#if defined __AVX512F__
+#if defined __x86_64__ && defined __AVX512F__
   return _mm512_roundscale_ps(x, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
 #else
   return simd_make_float16(__tg_floor(x.lo), __tg_floor(x.hi));
@@ -2341,7 +2767,7 @@ static SIMD_CFUNC simd_double4 __tg_floor(simd_double4 x) {
 }
  
 static SIMD_CFUNC simd_double8 __tg_floor(simd_double8 x) {
-#if defined __AVX512F__
+#if defined __x86_64__ && defined __AVX512F__
   return _mm512_roundscale_pd(x, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC);
 #else
   return simd_make_double8(__tg_floor(x.lo), __tg_floor(x.hi));
@@ -2387,7 +2813,7 @@ static SIMD_CFUNC simd_float8 __tg_rint(simd_float8 x) {
 }
  
 static SIMD_CFUNC simd_float16 __tg_rint(simd_float16 x) {
-#if defined __AVX512F__
+#if defined __x86_64__ && defined __AVX512F__
   return _mm512_roundscale_ps(x, _MM_FROUND_RINT);
 #else
   return simd_make_float16(__tg_rint(x.lo), __tg_rint(x.hi));
@@ -2425,7 +2851,7 @@ static SIMD_CFUNC simd_double4 __tg_rint(simd_double4 x) {
 }
  
 static SIMD_CFUNC simd_double8 __tg_rint(simd_double8 x) {
-#if defined __AVX512F__
+#if defined __x86_64__ && defined __AVX512F__
   return _mm512_roundscale_pd(x, _MM_FROUND_RINT);
 #else
   return simd_make_double8(__tg_rint(x.lo), __tg_rint(x.hi));
@@ -2472,7 +2898,7 @@ static SIMD_CFUNC simd_float8 __tg_trunc(simd_float8 x) {
 }
  
 static SIMD_CFUNC simd_float16 __tg_trunc(simd_float16 x) {
-#if defined __AVX512F__
+#if defined __x86_64__ && defined __AVX512F__
   return _mm512_roundscale_ps(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 #else
   return simd_make_float16(__tg_trunc(x.lo), __tg_trunc(x.hi));
@@ -2511,7 +2937,7 @@ static SIMD_CFUNC simd_double4 __tg_trunc(simd_double4 x) {
 }
  
 static SIMD_CFUNC simd_double8 __tg_trunc(simd_double8 x) {
-#if defined __AVX512F__
+#if defined __x86_64__ && defined __AVX512F__
   return _mm512_roundscale_pd(x, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC);
 #else
   return simd_make_double8(__tg_trunc(x.lo), __tg_trunc(x.hi));
@@ -2543,7 +2969,7 @@ static inline SIMD_CFUNC simd_float4 __tg_sin(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_sin_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_sin(simd_float8 x) {
   return _simd_sin_f8(x);
@@ -2554,7 +2980,7 @@ static inline SIMD_CFUNC simd_float8 __tg_sin(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_sin_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_sin(simd_float16 x) {
   return _simd_sin_f16(x);
@@ -2585,7 +3011,7 @@ static inline SIMD_CFUNC simd_double3 __tg_sin(simd_double3 x) {
   return simd_make_double3(__tg_sin(simd_make_double4(x)));
 }
   
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_sin_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_sin(simd_double4 x) {
   return _simd_sin_d4(x);
@@ -2596,7 +3022,7 @@ static inline SIMD_CFUNC simd_double4 __tg_sin(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_sin_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_sin(simd_double8 x) {
   return _simd_sin_d8(x);
@@ -2631,7 +3057,7 @@ static inline SIMD_CFUNC simd_float4 __tg_cos(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_cos_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_cos(simd_float8 x) {
   return _simd_cos_f8(x);
@@ -2642,7 +3068,7 @@ static inline SIMD_CFUNC simd_float8 __tg_cos(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_cos_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_cos(simd_float16 x) {
   return _simd_cos_f16(x);
@@ -2673,7 +3099,7 @@ static inline SIMD_CFUNC simd_double3 __tg_cos(simd_double3 x) {
   return simd_make_double3(__tg_cos(simd_make_double4(x)));
 }
   
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_cos_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_cos(simd_double4 x) {
   return _simd_cos_d4(x);
@@ -2684,7 +3110,7 @@ static inline SIMD_CFUNC simd_double4 __tg_cos(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_cos_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_cos(simd_double8 x) {
   return _simd_cos_d8(x);
@@ -2716,7 +3142,7 @@ static inline SIMD_CFUNC simd_float4 __tg_acos(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_acos_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_acos(simd_float8 x) {
   return _simd_acos_f8(x);
@@ -2727,7 +3153,7 @@ static inline SIMD_CFUNC simd_float8 __tg_acos(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_acos_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_acos(simd_float16 x) {
   return _simd_acos_f16(x);
@@ -2753,7 +3179,7 @@ static inline SIMD_CFUNC simd_double3 __tg_acos(simd_double3 x) {
   return simd_make_double3(__tg_acos(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_acos_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_acos(simd_double4 x) {
   return _simd_acos_d4(x);
@@ -2764,7 +3190,7 @@ static inline SIMD_CFUNC simd_double4 __tg_acos(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_acos_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_acos(simd_double8 x) {
   return _simd_acos_d8(x);
@@ -2795,7 +3221,7 @@ static inline SIMD_CFUNC simd_float4 __tg_asin(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_asin_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_asin(simd_float8 x) {
   return _simd_asin_f8(x);
@@ -2806,7 +3232,7 @@ static inline SIMD_CFUNC simd_float8 __tg_asin(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_asin_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_asin(simd_float16 x) {
   return _simd_asin_f16(x);
@@ -2832,7 +3258,7 @@ static inline SIMD_CFUNC simd_double3 __tg_asin(simd_double3 x) {
   return simd_make_double3(__tg_asin(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_asin_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_asin(simd_double4 x) {
   return _simd_asin_d4(x);
@@ -2843,7 +3269,7 @@ static inline SIMD_CFUNC simd_double4 __tg_asin(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_asin_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_asin(simd_double8 x) {
   return _simd_asin_d8(x);
@@ -2874,7 +3300,7 @@ static inline SIMD_CFUNC simd_float4 __tg_atan(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_atan_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_atan(simd_float8 x) {
   return _simd_atan_f8(x);
@@ -2885,7 +3311,7 @@ static inline SIMD_CFUNC simd_float8 __tg_atan(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_atan_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_atan(simd_float16 x) {
   return _simd_atan_f16(x);
@@ -2911,7 +3337,7 @@ static inline SIMD_CFUNC simd_double3 __tg_atan(simd_double3 x) {
   return simd_make_double3(__tg_atan(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_atan_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_atan(simd_double4 x) {
   return _simd_atan_d4(x);
@@ -2922,7 +3348,7 @@ static inline SIMD_CFUNC simd_double4 __tg_atan(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_atan_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_atan(simd_double8 x) {
   return _simd_atan_d8(x);
@@ -2953,7 +3379,7 @@ static inline SIMD_CFUNC simd_float4 __tg_tan(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_tan_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_tan(simd_float8 x) {
   return _simd_tan_f8(x);
@@ -2964,7 +3390,7 @@ static inline SIMD_CFUNC simd_float8 __tg_tan(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_tan_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_tan(simd_float16 x) {
   return _simd_tan_f16(x);
@@ -2990,7 +3416,7 @@ static inline SIMD_CFUNC simd_double3 __tg_tan(simd_double3 x) {
   return simd_make_double3(__tg_tan(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_tan_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_tan(simd_double4 x) {
   return _simd_tan_d4(x);
@@ -3001,7 +3427,7 @@ static inline SIMD_CFUNC simd_double4 __tg_tan(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_tan_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_tan(simd_double8 x) {
   return _simd_tan_d8(x);
@@ -3033,7 +3459,7 @@ static inline SIMD_CFUNC simd_float4 __tg_cospi(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_cospi_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_cospi(simd_float8 x) {
   return _simd_cospi_f8(x);
@@ -3044,7 +3470,7 @@ static inline SIMD_CFUNC simd_float8 __tg_cospi(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_cospi_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_cospi(simd_float16 x) {
   return _simd_cospi_f16(x);
@@ -3070,7 +3496,7 @@ static inline SIMD_CFUNC simd_double3 __tg_cospi(simd_double3 x) {
   return simd_make_double3(__tg_cospi(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_cospi_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_cospi(simd_double4 x) {
   return _simd_cospi_d4(x);
@@ -3081,7 +3507,7 @@ static inline SIMD_CFUNC simd_double4 __tg_cospi(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_cospi_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_cospi(simd_double8 x) {
   return _simd_cospi_d8(x);
@@ -3114,7 +3540,7 @@ static inline SIMD_CFUNC simd_float4 __tg_sinpi(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_sinpi_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_sinpi(simd_float8 x) {
   return _simd_sinpi_f8(x);
@@ -3125,7 +3551,7 @@ static inline SIMD_CFUNC simd_float8 __tg_sinpi(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_sinpi_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_sinpi(simd_float16 x) {
   return _simd_sinpi_f16(x);
@@ -3151,7 +3577,7 @@ static inline SIMD_CFUNC simd_double3 __tg_sinpi(simd_double3 x) {
   return simd_make_double3(__tg_sinpi(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_sinpi_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_sinpi(simd_double4 x) {
   return _simd_sinpi_d4(x);
@@ -3162,7 +3588,7 @@ static inline SIMD_CFUNC simd_double4 __tg_sinpi(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_sinpi_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_sinpi(simd_double8 x) {
   return _simd_sinpi_d8(x);
@@ -3195,7 +3621,7 @@ static inline SIMD_CFUNC simd_float4 __tg_tanpi(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_tanpi_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_tanpi(simd_float8 x) {
   return _simd_tanpi_f8(x);
@@ -3206,7 +3632,7 @@ static inline SIMD_CFUNC simd_float8 __tg_tanpi(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_tanpi_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_tanpi(simd_float16 x) {
   return _simd_tanpi_f16(x);
@@ -3232,7 +3658,7 @@ static inline SIMD_CFUNC simd_double3 __tg_tanpi(simd_double3 x) {
   return simd_make_double3(__tg_tanpi(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_tanpi_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_tanpi(simd_double4 x) {
   return _simd_tanpi_d4(x);
@@ -3243,7 +3669,7 @@ static inline SIMD_CFUNC simd_double4 __tg_tanpi(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_tanpi_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_tanpi(simd_double8 x) {
   return _simd_tanpi_d8(x);
@@ -3275,7 +3701,7 @@ static inline SIMD_CFUNC simd_float4 __tg_acosh(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_acosh_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_acosh(simd_float8 x) {
   return _simd_acosh_f8(x);
@@ -3286,7 +3712,7 @@ static inline SIMD_CFUNC simd_float8 __tg_acosh(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_acosh_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_acosh(simd_float16 x) {
   return _simd_acosh_f16(x);
@@ -3312,7 +3738,7 @@ static inline SIMD_CFUNC simd_double3 __tg_acosh(simd_double3 x) {
   return simd_make_double3(__tg_acosh(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_acosh_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_acosh(simd_double4 x) {
   return _simd_acosh_d4(x);
@@ -3323,7 +3749,7 @@ static inline SIMD_CFUNC simd_double4 __tg_acosh(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_acosh_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_acosh(simd_double8 x) {
   return _simd_acosh_d8(x);
@@ -3354,7 +3780,7 @@ static inline SIMD_CFUNC simd_float4 __tg_asinh(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_asinh_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_asinh(simd_float8 x) {
   return _simd_asinh_f8(x);
@@ -3365,7 +3791,7 @@ static inline SIMD_CFUNC simd_float8 __tg_asinh(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_asinh_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_asinh(simd_float16 x) {
   return _simd_asinh_f16(x);
@@ -3391,7 +3817,7 @@ static inline SIMD_CFUNC simd_double3 __tg_asinh(simd_double3 x) {
   return simd_make_double3(__tg_asinh(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_asinh_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_asinh(simd_double4 x) {
   return _simd_asinh_d4(x);
@@ -3402,7 +3828,7 @@ static inline SIMD_CFUNC simd_double4 __tg_asinh(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_asinh_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_asinh(simd_double8 x) {
   return _simd_asinh_d8(x);
@@ -3433,7 +3859,7 @@ static inline SIMD_CFUNC simd_float4 __tg_atanh(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_atanh_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_atanh(simd_float8 x) {
   return _simd_atanh_f8(x);
@@ -3444,7 +3870,7 @@ static inline SIMD_CFUNC simd_float8 __tg_atanh(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_atanh_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_atanh(simd_float16 x) {
   return _simd_atanh_f16(x);
@@ -3470,7 +3896,7 @@ static inline SIMD_CFUNC simd_double3 __tg_atanh(simd_double3 x) {
   return simd_make_double3(__tg_atanh(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_atanh_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_atanh(simd_double4 x) {
   return _simd_atanh_d4(x);
@@ -3481,7 +3907,7 @@ static inline SIMD_CFUNC simd_double4 __tg_atanh(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_atanh_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_atanh(simd_double8 x) {
   return _simd_atanh_d8(x);
@@ -3512,7 +3938,7 @@ static inline SIMD_CFUNC simd_float4 __tg_cosh(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_cosh_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_cosh(simd_float8 x) {
   return _simd_cosh_f8(x);
@@ -3523,7 +3949,7 @@ static inline SIMD_CFUNC simd_float8 __tg_cosh(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_cosh_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_cosh(simd_float16 x) {
   return _simd_cosh_f16(x);
@@ -3549,7 +3975,7 @@ static inline SIMD_CFUNC simd_double3 __tg_cosh(simd_double3 x) {
   return simd_make_double3(__tg_cosh(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_cosh_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_cosh(simd_double4 x) {
   return _simd_cosh_d4(x);
@@ -3560,7 +3986,7 @@ static inline SIMD_CFUNC simd_double4 __tg_cosh(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_cosh_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_cosh(simd_double8 x) {
   return _simd_cosh_d8(x);
@@ -3591,7 +4017,7 @@ static inline SIMD_CFUNC simd_float4 __tg_sinh(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_sinh_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_sinh(simd_float8 x) {
   return _simd_sinh_f8(x);
@@ -3602,7 +4028,7 @@ static inline SIMD_CFUNC simd_float8 __tg_sinh(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_sinh_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_sinh(simd_float16 x) {
   return _simd_sinh_f16(x);
@@ -3628,7 +4054,7 @@ static inline SIMD_CFUNC simd_double3 __tg_sinh(simd_double3 x) {
   return simd_make_double3(__tg_sinh(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_sinh_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_sinh(simd_double4 x) {
   return _simd_sinh_d4(x);
@@ -3639,7 +4065,7 @@ static inline SIMD_CFUNC simd_double4 __tg_sinh(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_sinh_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_sinh(simd_double8 x) {
   return _simd_sinh_d8(x);
@@ -3670,7 +4096,7 @@ static inline SIMD_CFUNC simd_float4 __tg_tanh(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_tanh_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_tanh(simd_float8 x) {
   return _simd_tanh_f8(x);
@@ -3681,7 +4107,7 @@ static inline SIMD_CFUNC simd_float8 __tg_tanh(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_tanh_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_tanh(simd_float16 x) {
   return _simd_tanh_f16(x);
@@ -3707,7 +4133,7 @@ static inline SIMD_CFUNC simd_double3 __tg_tanh(simd_double3 x) {
   return simd_make_double3(__tg_tanh(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_tanh_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_tanh(simd_double4 x) {
   return _simd_tanh_d4(x);
@@ -3718,7 +4144,7 @@ static inline SIMD_CFUNC simd_double4 __tg_tanh(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_tanh_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_tanh(simd_double8 x) {
   return _simd_tanh_d8(x);
@@ -3749,7 +4175,7 @@ static inline SIMD_CFUNC simd_float4 __tg_exp(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_exp_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_exp(simd_float8 x) {
   return _simd_exp_f8(x);
@@ -3760,7 +4186,7 @@ static inline SIMD_CFUNC simd_float8 __tg_exp(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_exp_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_exp(simd_float16 x) {
   return _simd_exp_f16(x);
@@ -3786,7 +4212,7 @@ static inline SIMD_CFUNC simd_double3 __tg_exp(simd_double3 x) {
   return simd_make_double3(__tg_exp(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_exp_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_exp(simd_double4 x) {
   return _simd_exp_d4(x);
@@ -3797,7 +4223,7 @@ static inline SIMD_CFUNC simd_double4 __tg_exp(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_exp_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_exp(simd_double8 x) {
   return _simd_exp_d8(x);
@@ -3828,7 +4254,7 @@ static inline SIMD_CFUNC simd_float4 __tg_exp2(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_exp2_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_exp2(simd_float8 x) {
   return _simd_exp2_f8(x);
@@ -3839,7 +4265,7 @@ static inline SIMD_CFUNC simd_float8 __tg_exp2(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_exp2_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_exp2(simd_float16 x) {
   return _simd_exp2_f16(x);
@@ -3865,7 +4291,7 @@ static inline SIMD_CFUNC simd_double3 __tg_exp2(simd_double3 x) {
   return simd_make_double3(__tg_exp2(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_exp2_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_exp2(simd_double4 x) {
   return _simd_exp2_d4(x);
@@ -3876,7 +4302,7 @@ static inline SIMD_CFUNC simd_double4 __tg_exp2(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_exp2_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_exp2(simd_double8 x) {
   return _simd_exp2_d8(x);
@@ -3908,7 +4334,7 @@ static inline SIMD_CFUNC simd_float4 __tg_exp10(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_exp10_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_exp10(simd_float8 x) {
   return _simd_exp10_f8(x);
@@ -3919,7 +4345,7 @@ static inline SIMD_CFUNC simd_float8 __tg_exp10(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_exp10_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_exp10(simd_float16 x) {
   return _simd_exp10_f16(x);
@@ -3945,7 +4371,7 @@ static inline SIMD_CFUNC simd_double3 __tg_exp10(simd_double3 x) {
   return simd_make_double3(__tg_exp10(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_exp10_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_exp10(simd_double4 x) {
   return _simd_exp10_d4(x);
@@ -3956,7 +4382,7 @@ static inline SIMD_CFUNC simd_double4 __tg_exp10(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_exp10_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_exp10(simd_double8 x) {
   return _simd_exp10_d8(x);
@@ -3988,7 +4414,7 @@ static inline SIMD_CFUNC simd_float4 __tg_expm1(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_expm1_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_expm1(simd_float8 x) {
   return _simd_expm1_f8(x);
@@ -3999,7 +4425,7 @@ static inline SIMD_CFUNC simd_float8 __tg_expm1(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_expm1_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_expm1(simd_float16 x) {
   return _simd_expm1_f16(x);
@@ -4025,7 +4451,7 @@ static inline SIMD_CFUNC simd_double3 __tg_expm1(simd_double3 x) {
   return simd_make_double3(__tg_expm1(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_expm1_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_expm1(simd_double4 x) {
   return _simd_expm1_d4(x);
@@ -4036,7 +4462,7 @@ static inline SIMD_CFUNC simd_double4 __tg_expm1(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_expm1_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_expm1(simd_double8 x) {
   return _simd_expm1_d8(x);
@@ -4067,7 +4493,7 @@ static inline SIMD_CFUNC simd_float4 __tg_log(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_log_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_log(simd_float8 x) {
   return _simd_log_f8(x);
@@ -4078,7 +4504,7 @@ static inline SIMD_CFUNC simd_float8 __tg_log(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_log_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_log(simd_float16 x) {
   return _simd_log_f16(x);
@@ -4104,7 +4530,7 @@ static inline SIMD_CFUNC simd_double3 __tg_log(simd_double3 x) {
   return simd_make_double3(__tg_log(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_log_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_log(simd_double4 x) {
   return _simd_log_d4(x);
@@ -4115,7 +4541,7 @@ static inline SIMD_CFUNC simd_double4 __tg_log(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_log_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_log(simd_double8 x) {
   return _simd_log_d8(x);
@@ -4146,7 +4572,7 @@ static inline SIMD_CFUNC simd_float4 __tg_log2(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_log2_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_log2(simd_float8 x) {
   return _simd_log2_f8(x);
@@ -4157,7 +4583,7 @@ static inline SIMD_CFUNC simd_float8 __tg_log2(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_log2_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_log2(simd_float16 x) {
   return _simd_log2_f16(x);
@@ -4183,7 +4609,7 @@ static inline SIMD_CFUNC simd_double3 __tg_log2(simd_double3 x) {
   return simd_make_double3(__tg_log2(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_log2_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_log2(simd_double4 x) {
   return _simd_log2_d4(x);
@@ -4194,7 +4620,7 @@ static inline SIMD_CFUNC simd_double4 __tg_log2(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_log2_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_log2(simd_double8 x) {
   return _simd_log2_d8(x);
@@ -4225,7 +4651,7 @@ static inline SIMD_CFUNC simd_float4 __tg_log10(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_log10_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_log10(simd_float8 x) {
   return _simd_log10_f8(x);
@@ -4236,7 +4662,7 @@ static inline SIMD_CFUNC simd_float8 __tg_log10(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_log10_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_log10(simd_float16 x) {
   return _simd_log10_f16(x);
@@ -4262,7 +4688,7 @@ static inline SIMD_CFUNC simd_double3 __tg_log10(simd_double3 x) {
   return simd_make_double3(__tg_log10(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_log10_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_log10(simd_double4 x) {
   return _simd_log10_d4(x);
@@ -4273,7 +4699,7 @@ static inline SIMD_CFUNC simd_double4 __tg_log10(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_log10_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_log10(simd_double8 x) {
   return _simd_log10_d8(x);
@@ -4304,7 +4730,7 @@ static inline SIMD_CFUNC simd_float4 __tg_log1p(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_log1p_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_log1p(simd_float8 x) {
   return _simd_log1p_f8(x);
@@ -4315,7 +4741,7 @@ static inline SIMD_CFUNC simd_float8 __tg_log1p(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_log1p_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_log1p(simd_float16 x) {
   return _simd_log1p_f16(x);
@@ -4341,7 +4767,7 @@ static inline SIMD_CFUNC simd_double3 __tg_log1p(simd_double3 x) {
   return simd_make_double3(__tg_log1p(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_log1p_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_log1p(simd_double4 x) {
   return _simd_log1p_d4(x);
@@ -4352,7 +4778,7 @@ static inline SIMD_CFUNC simd_double4 __tg_log1p(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_log1p_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_log1p(simd_double8 x) {
   return _simd_log1p_d8(x);
@@ -4383,7 +4809,7 @@ static inline SIMD_CFUNC simd_float4 __tg_cbrt(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_cbrt_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_cbrt(simd_float8 x) {
   return _simd_cbrt_f8(x);
@@ -4394,7 +4820,7 @@ static inline SIMD_CFUNC simd_float8 __tg_cbrt(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_cbrt_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_cbrt(simd_float16 x) {
   return _simd_cbrt_f16(x);
@@ -4420,7 +4846,7 @@ static inline SIMD_CFUNC simd_double3 __tg_cbrt(simd_double3 x) {
   return simd_make_double3(__tg_cbrt(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_cbrt_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_cbrt(simd_double4 x) {
   return _simd_cbrt_d4(x);
@@ -4431,7 +4857,7 @@ static inline SIMD_CFUNC simd_double4 __tg_cbrt(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_cbrt_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_cbrt(simd_double8 x) {
   return _simd_cbrt_d8(x);
@@ -4462,7 +4888,7 @@ static inline SIMD_CFUNC simd_float4 __tg_erf(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_erf_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_erf(simd_float8 x) {
   return _simd_erf_f8(x);
@@ -4473,7 +4899,7 @@ static inline SIMD_CFUNC simd_float8 __tg_erf(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_erf_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_erf(simd_float16 x) {
   return _simd_erf_f16(x);
@@ -4499,7 +4925,7 @@ static inline SIMD_CFUNC simd_double3 __tg_erf(simd_double3 x) {
   return simd_make_double3(__tg_erf(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_erf_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_erf(simd_double4 x) {
   return _simd_erf_d4(x);
@@ -4510,7 +4936,7 @@ static inline SIMD_CFUNC simd_double4 __tg_erf(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_erf_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_erf(simd_double8 x) {
   return _simd_erf_d8(x);
@@ -4541,7 +4967,7 @@ static inline SIMD_CFUNC simd_float4 __tg_erfc(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_erfc_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_erfc(simd_float8 x) {
   return _simd_erfc_f8(x);
@@ -4552,7 +4978,7 @@ static inline SIMD_CFUNC simd_float8 __tg_erfc(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_erfc_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_erfc(simd_float16 x) {
   return _simd_erfc_f16(x);
@@ -4578,7 +5004,7 @@ static inline SIMD_CFUNC simd_double3 __tg_erfc(simd_double3 x) {
   return simd_make_double3(__tg_erfc(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_erfc_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_erfc(simd_double4 x) {
   return _simd_erfc_d4(x);
@@ -4589,7 +5015,7 @@ static inline SIMD_CFUNC simd_double4 __tg_erfc(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_erfc_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_erfc(simd_double8 x) {
   return _simd_erfc_d8(x);
@@ -4620,7 +5046,7 @@ static inline SIMD_CFUNC simd_float4 __tg_tgamma(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_tgamma_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_tgamma(simd_float8 x) {
   return _simd_tgamma_f8(x);
@@ -4631,7 +5057,7 @@ static inline SIMD_CFUNC simd_float8 __tg_tgamma(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_tgamma_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_tgamma(simd_float16 x) {
   return _simd_tgamma_f16(x);
@@ -4657,7 +5083,7 @@ static inline SIMD_CFUNC simd_double3 __tg_tgamma(simd_double3 x) {
   return simd_make_double3(__tg_tgamma(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_tgamma_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_tgamma(simd_double4 x) {
   return _simd_tgamma_d4(x);
@@ -4668,7 +5094,7 @@ static inline SIMD_CFUNC simd_double4 __tg_tgamma(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_tgamma_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_tgamma(simd_double8 x) {
   return _simd_tgamma_d8(x);
@@ -4703,7 +5129,7 @@ static inline SIMD_CFUNC simd_float4 __tg_round(simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_round_f8(simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_round(simd_float8 x) {
   return _simd_round_f8(x);
@@ -4714,7 +5140,7 @@ static inline SIMD_CFUNC simd_float8 __tg_round(simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_round_f16(simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_round(simd_float16 x) {
   return _simd_round_f16(x);
@@ -4744,7 +5170,7 @@ static inline SIMD_CFUNC simd_double3 __tg_round(simd_double3 x) {
   return simd_make_double3(__tg_round(simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_round_d4(simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_round(simd_double4 x) {
   return _simd_round_d4(x);
@@ -4755,7 +5181,7 @@ static inline SIMD_CFUNC simd_double4 __tg_round(simd_double4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_round_d8(simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_round(simd_double8 x) {
   return _simd_round_d8(x);
@@ -4786,7 +5212,7 @@ static inline SIMD_CFUNC simd_float4 __tg_atan2(simd_float4 y, simd_float4 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_atan2_f8(simd_float8 y, simd_float8 x);
 static inline SIMD_CFUNC simd_float8 __tg_atan2(simd_float8 y, simd_float8 x) {
   return _simd_atan2_f8(y, x);
@@ -4797,7 +5223,7 @@ static inline SIMD_CFUNC simd_float8 __tg_atan2(simd_float8 y, simd_float8 x) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_atan2_f16(simd_float16 y, simd_float16 x);
 static inline SIMD_CFUNC simd_float16 __tg_atan2(simd_float16 y, simd_float16 x) {
   return _simd_atan2_f16(y, x);
@@ -4823,7 +5249,7 @@ static inline SIMD_CFUNC simd_double3 __tg_atan2(simd_double3 y, simd_double3 x)
   return simd_make_double3(__tg_atan2(simd_make_double4(y), simd_make_double4(x)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_atan2_d4(simd_double4 y, simd_double4 x);
 static inline SIMD_CFUNC simd_double4 __tg_atan2(simd_double4 y, simd_double4 x) {
   return _simd_atan2_d4(y, x);
@@ -4834,7 +5260,7 @@ static inline SIMD_CFUNC simd_double4 __tg_atan2(simd_double4 y, simd_double4 x)
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_atan2_d8(simd_double8 y, simd_double8 x);
 static inline SIMD_CFUNC simd_double8 __tg_atan2(simd_double8 y, simd_double8 x) {
   return _simd_atan2_d8(y, x);
@@ -4865,7 +5291,7 @@ static inline SIMD_CFUNC simd_float4 __tg_hypot(simd_float4 x, simd_float4 y) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_hypot_f8(simd_float8 x, simd_float8 y);
 static inline SIMD_CFUNC simd_float8 __tg_hypot(simd_float8 x, simd_float8 y) {
   return _simd_hypot_f8(x, y);
@@ -4876,7 +5302,7 @@ static inline SIMD_CFUNC simd_float8 __tg_hypot(simd_float8 x, simd_float8 y) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_hypot_f16(simd_float16 x, simd_float16 y);
 static inline SIMD_CFUNC simd_float16 __tg_hypot(simd_float16 x, simd_float16 y) {
   return _simd_hypot_f16(x, y);
@@ -4902,7 +5328,7 @@ static inline SIMD_CFUNC simd_double3 __tg_hypot(simd_double3 x, simd_double3 y)
   return simd_make_double3(__tg_hypot(simd_make_double4(x), simd_make_double4(y)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_hypot_d4(simd_double4 x, simd_double4 y);
 static inline SIMD_CFUNC simd_double4 __tg_hypot(simd_double4 x, simd_double4 y) {
   return _simd_hypot_d4(x, y);
@@ -4913,7 +5339,7 @@ static inline SIMD_CFUNC simd_double4 __tg_hypot(simd_double4 x, simd_double4 y)
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_hypot_d8(simd_double8 x, simd_double8 y);
 static inline SIMD_CFUNC simd_double8 __tg_hypot(simd_double8 x, simd_double8 y) {
   return _simd_hypot_d8(x, y);
@@ -4944,7 +5370,7 @@ static inline SIMD_CFUNC simd_float4 __tg_pow(simd_float4 x, simd_float4 y) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_pow_f8(simd_float8 x, simd_float8 y);
 static inline SIMD_CFUNC simd_float8 __tg_pow(simd_float8 x, simd_float8 y) {
   return _simd_pow_f8(x, y);
@@ -4955,7 +5381,7 @@ static inline SIMD_CFUNC simd_float8 __tg_pow(simd_float8 x, simd_float8 y) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_pow_f16(simd_float16 x, simd_float16 y);
 static inline SIMD_CFUNC simd_float16 __tg_pow(simd_float16 x, simd_float16 y) {
   return _simd_pow_f16(x, y);
@@ -4981,7 +5407,7 @@ static inline SIMD_CFUNC simd_double3 __tg_pow(simd_double3 x, simd_double3 y) {
   return simd_make_double3(__tg_pow(simd_make_double4(x), simd_make_double4(y)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_pow_d4(simd_double4 x, simd_double4 y);
 static inline SIMD_CFUNC simd_double4 __tg_pow(simd_double4 x, simd_double4 y) {
   return _simd_pow_d4(x, y);
@@ -4992,7 +5418,7 @@ static inline SIMD_CFUNC simd_double4 __tg_pow(simd_double4 x, simd_double4 y) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_pow_d8(simd_double8 x, simd_double8 y);
 static inline SIMD_CFUNC simd_double8 __tg_pow(simd_double8 x, simd_double8 y) {
   return _simd_pow_d8(x, y);
@@ -5023,7 +5449,7 @@ static inline SIMD_CFUNC simd_float4 __tg_fmod(simd_float4 x, simd_float4 y) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_fmod_f8(simd_float8 x, simd_float8 y);
 static inline SIMD_CFUNC simd_float8 __tg_fmod(simd_float8 x, simd_float8 y) {
   return _simd_fmod_f8(x, y);
@@ -5034,7 +5460,7 @@ static inline SIMD_CFUNC simd_float8 __tg_fmod(simd_float8 x, simd_float8 y) {
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_fmod_f16(simd_float16 x, simd_float16 y);
 static inline SIMD_CFUNC simd_float16 __tg_fmod(simd_float16 x, simd_float16 y) {
   return _simd_fmod_f16(x, y);
@@ -5060,7 +5486,7 @@ static inline SIMD_CFUNC simd_double3 __tg_fmod(simd_double3 x, simd_double3 y)
   return simd_make_double3(__tg_fmod(simd_make_double4(x), simd_make_double4(y)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_fmod_d4(simd_double4 x, simd_double4 y);
 static inline SIMD_CFUNC simd_double4 __tg_fmod(simd_double4 x, simd_double4 y) {
   return _simd_fmod_d4(x, y);
@@ -5071,7 +5497,7 @@ static inline SIMD_CFUNC simd_double4 __tg_fmod(simd_double4 x, simd_double4 y)
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_fmod_d8(simd_double8 x, simd_double8 y);
 static inline SIMD_CFUNC simd_double8 __tg_fmod(simd_double8 x, simd_double8 y) {
   return _simd_fmod_d8(x, y);
@@ -5102,7 +5528,7 @@ static inline SIMD_CFUNC simd_float4 __tg_remainder(simd_float4 x, simd_float4 y
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_remainder_f8(simd_float8 x, simd_float8 y);
 static inline SIMD_CFUNC simd_float8 __tg_remainder(simd_float8 x, simd_float8 y) {
   return _simd_remainder_f8(x, y);
@@ -5113,7 +5539,7 @@ static inline SIMD_CFUNC simd_float8 __tg_remainder(simd_float8 x, simd_float8 y
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_remainder_f16(simd_float16 x, simd_float16 y);
 static inline SIMD_CFUNC simd_float16 __tg_remainder(simd_float16 x, simd_float16 y) {
   return _simd_remainder_f16(x, y);
@@ -5139,7 +5565,7 @@ static inline SIMD_CFUNC simd_double3 __tg_remainder(simd_double3 x, simd_double
   return simd_make_double3(__tg_remainder(simd_make_double4(x), simd_make_double4(y)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_remainder_d4(simd_double4 x, simd_double4 y);
 static inline SIMD_CFUNC simd_double4 __tg_remainder(simd_double4 x, simd_double4 y) {
   return _simd_remainder_d4(x, y);
@@ -5150,7 +5576,7 @@ static inline SIMD_CFUNC simd_double4 __tg_remainder(simd_double4 x, simd_double
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_remainder_d8(simd_double8 x, simd_double8 y);
 static inline SIMD_CFUNC simd_double8 __tg_remainder(simd_double8 x, simd_double8 y) {
   return _simd_remainder_d8(x, y);
@@ -5181,7 +5607,7 @@ static inline SIMD_CFUNC simd_float4 __tg_nextafter(simd_float4 x, simd_float4 y
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_float8 _simd_nextafter_f8(simd_float8 x, simd_float8 y);
 static inline SIMD_CFUNC simd_float8 __tg_nextafter(simd_float8 x, simd_float8 y) {
   return _simd_nextafter_f8(x, y);
@@ -5192,7 +5618,7 @@ static inline SIMD_CFUNC simd_float8 __tg_nextafter(simd_float8 x, simd_float8 y
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_float16 _simd_nextafter_f16(simd_float16 x, simd_float16 y);
 static inline SIMD_CFUNC simd_float16 __tg_nextafter(simd_float16 x, simd_float16 y) {
   return _simd_nextafter_f16(x, y);
@@ -5218,7 +5644,7 @@ static inline SIMD_CFUNC simd_double3 __tg_nextafter(simd_double3 x, simd_double
   return simd_make_double3(__tg_nextafter(simd_make_double4(x), simd_make_double4(y)));
 }
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX2__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX2__
 extern simd_double4 _simd_nextafter_d4(simd_double4 x, simd_double4 y);
 static inline SIMD_CFUNC simd_double4 __tg_nextafter(simd_double4 x, simd_double4 y) {
   return _simd_nextafter_d4(x, y);
@@ -5229,7 +5655,7 @@ static inline SIMD_CFUNC simd_double4 __tg_nextafter(simd_double4 x, simd_double
 }
 #endif
 
-#if SIMD_LIBRARY_VERSION >= 3 && defined __AVX512F__
+#if SIMD_LIBRARY_VERSION >= 3 && defined __x86_64__ && defined __AVX512F__
 extern simd_double8 _simd_nextafter_d8(simd_double8 x, simd_double8 y);
 static inline SIMD_CFUNC simd_double8 __tg_nextafter(simd_double8 x, simd_double8 y) {
   return _simd_nextafter_d8(x, y);
@@ -5240,6 +5666,197 @@ static inline SIMD_CFUNC simd_double8 __tg_nextafter(simd_double8 x, simd_double
 }
 #endif
 
+#if SIMD_LIBRARY_VERSION >= 5
+#pragma mark - sincos implementation
+static inline SIMD_NONCONST void __tg_sincos(simd_float2 x, simd_float2 *sinp, simd_float2 *cosp) {
+    simd_float4 sin_val;
+    simd_float4 cos_val;
+    __tg_sincos(simd_make_float4(x), &sin_val, &cos_val);
+    *sinp = simd_make_float2(sin_val);
+    *cosp = simd_make_float2(cos_val);
+}
+
+static inline SIMD_NONCONST void __tg_sincos(simd_float3 x, simd_float3 *sinp, simd_float3 *cosp) {
+    simd_float4 sin_val;
+    simd_float4 cos_val;
+    __tg_sincos(simd_make_float4(x), &sin_val, &cos_val);
+    *sinp = simd_make_float3(sin_val);
+    *cosp = simd_make_float3(cos_val);
+}
+
+extern void _simd_sincos_f4(simd_float4 x, simd_float4 *sinp, simd_float4 *cosp);
+static inline SIMD_NONCONST void __tg_sincos(simd_float4 x, simd_float4 *sinp, simd_float4 *cosp) {
+  return _simd_sincos_f4(x, sinp, cosp);
+}
+
+static inline SIMD_NONCONST void __tg_sincos(simd_float8 x, simd_float8 *sinp, simd_float8 *cosp) {
+  __tg_sincos(x.lo, (simd_float4 *)sinp+0, (simd_float4 *)cosp+0);
+  __tg_sincos(x.hi, (simd_float4 *)sinp+1, (simd_float4 *)cosp+1);
+}
+
+static inline SIMD_NONCONST void __tg_sincos(simd_float16 x, simd_float16 *sinp, simd_float16 *cosp) {
+  __tg_sincos(x.lo, (simd_float8 *)sinp+0, (simd_float8 *)cosp+0);
+  __tg_sincos(x.hi, (simd_float8 *)sinp+1, (simd_float8 *)cosp+1);
+}
+
+extern void _simd_sincos_d2(simd_double2 x, simd_double2 *sinp, simd_double2 *cosp);
+static inline SIMD_NONCONST void __tg_sincos(simd_double2 x, simd_double2 *sinp, simd_double2 *cosp) {
+  return _simd_sincos_d2(x, sinp, cosp);
+}
+
+static inline SIMD_NONCONST void __tg_sincos(simd_double3 x, simd_double3 *sinp, simd_double3 *cosp) {
+    simd_double4 sin_val;
+    simd_double4 cos_val;
+    __tg_sincos(simd_make_double4(x), &sin_val, &cos_val);
+    *sinp = simd_make_double3(sin_val);
+    *cosp = simd_make_double3(cos_val);
+}
+
+static inline SIMD_NONCONST void __tg_sincos(simd_double4 x, simd_double4 *sinp, simd_double4 *cosp) {
+  __tg_sincos(x.lo, (simd_double2 *)sinp+0, (simd_double2 *)cosp+0);
+  __tg_sincos(x.hi, (simd_double2 *)sinp+1, (simd_double2 *)cosp+1);
+}
+
+static inline SIMD_NONCONST void __tg_sincos(simd_double8 x, simd_double8 *sinp, simd_double8 *cosp) {
+  __tg_sincos(x.lo, (simd_double4 *)sinp+0, (simd_double4 *)cosp+0);
+  __tg_sincos(x.hi, (simd_double4 *)sinp+1, (simd_double4 *)cosp+1);
+}
+
+#pragma mark - sincospi implementation
+static inline SIMD_NONCONST void __tg_sincospi(simd_float2 x, simd_float2 *sinp, simd_float2 *cosp) {
+    simd_float4 sin_val;
+    simd_float4 cos_val;
+    __tg_sincospi(simd_make_float4(x), &sin_val, &cos_val);
+    *sinp = simd_make_float2(sin_val);
+    *cosp = simd_make_float2(cos_val);
+}
+
+static inline SIMD_NONCONST void __tg_sincospi(simd_float3 x, simd_float3 *sinp, simd_float3 *cosp) {
+    simd_float4 sin_val;
+    simd_float4 cos_val;
+    __tg_sincospi(simd_make_float4(x), &sin_val, &cos_val);
+    *sinp = simd_make_float3(sin_val);
+    *cosp = simd_make_float3(cos_val);
+}
+
+extern void _simd_sincospi_f4(simd_float4 x, simd_float4 *sinp, simd_float4 *cosp);
+static inline SIMD_NONCONST void __tg_sincospi(simd_float4 x, simd_float4 *sinp, simd_float4 *cosp) {
+  return _simd_sincospi_f4(x, sinp, cosp);
+}
+
+static inline SIMD_NONCONST void __tg_sincospi(simd_float8 x, simd_float8 *sinp, simd_float8 *cosp) {
+  __tg_sincospi(x.lo, (simd_float4 *)sinp+0, (simd_float4 *)cosp+0);
+  __tg_sincospi(x.hi, (simd_float4 *)sinp+1, (simd_float4 *)cosp+1);
+}
+
+static inline SIMD_NONCONST void __tg_sincospi(simd_float16 x, simd_float16 *sinp, simd_float16 *cosp) {
+  __tg_sincospi(x.lo, (simd_float8 *)sinp+0, (simd_float8 *)cosp+0);
+  __tg_sincospi(x.hi, (simd_float8 *)sinp+1, (simd_float8 *)cosp+1);
+}
+
+extern void _simd_sincospi_d2(simd_double2 x, simd_double2 *sinp, simd_double2 *cosp);
+static inline SIMD_NONCONST void __tg_sincospi(simd_double2 x, simd_double2 *sinp, simd_double2 *cosp) {
+  return _simd_sincospi_d2(x, sinp, cosp);
+}
+
+static inline SIMD_NONCONST void __tg_sincospi(simd_double3 x, simd_double3 *sinp, simd_double3 *cosp) {
+    simd_double4 sin_val;
+    simd_double4 cos_val;
+    __tg_sincospi(simd_make_double4(x), &sin_val, &cos_val);
+    *sinp = simd_make_double3(sin_val);
+    *cosp = simd_make_double3(cos_val);
+}
+
+static inline SIMD_NONCONST void __tg_sincospi(simd_double4 x, simd_double4 *sinp, simd_double4 *cosp) {
+  __tg_sincospi(x.lo, (simd_double2 *)sinp+0, (simd_double2 *)cosp+0);
+  __tg_sincospi(x.hi, (simd_double2 *)sinp+1, (simd_double2 *)cosp+1);
+}
+
+static inline SIMD_NONCONST void __tg_sincospi(simd_double8 x, simd_double8 *sinp, simd_double8 *cosp) {
+  __tg_sincospi(x.lo, (simd_double4 *)sinp+0, (simd_double4 *)cosp+0);
+  __tg_sincospi(x.hi, (simd_double4 *)sinp+1, (simd_double4 *)cosp+1);
+}
+
+#endif // SIMD_LIBRARY_VERSION >= 5
+#pragma mark - lgamma implementation
+static inline SIMD_CFUNC simd_float2 __tg_lgamma(simd_float2 x) {
+  return simd_make_float2(__tg_lgamma(simd_make_float4(x)));
+}
+
+static inline SIMD_CFUNC simd_float3 __tg_lgamma(simd_float3 x) {
+  return simd_make_float3(__tg_lgamma(simd_make_float4(x)));
+}
+
+#if SIMD_LIBRARY_VERSION >= 4
+extern simd_float4 _simd_lgamma_f4(simd_float4 x);
+static inline SIMD_CFUNC simd_float4 __tg_lgamma(simd_float4 x) {
+  return _simd_lgamma_f4(x);
+}
+#else
+static inline SIMD_CFUNC simd_float4 __tg_lgamma(simd_float4 x) {
+  return simd_make_float4(lgamma(x.x), lgamma(x.y), lgamma(x.z), lgamma(x.w));
+}
+#endif
+
+#if SIMD_LIBRARY_VERSION >= 4 && defined __x86_64__ && defined __AVX2__
+extern simd_float8 _simd_lgamma_f8(simd_float8 x);
+static inline SIMD_CFUNC simd_float8 __tg_lgamma(simd_float8 x) {
+  return _simd_lgamma_f8(x);
+}
+#else
+static inline SIMD_CFUNC simd_float8 __tg_lgamma(simd_float8 x) {
+  return simd_make_float8(__tg_lgamma(x.lo), __tg_lgamma(x.hi));
+}
+#endif
+
+#if SIMD_LIBRARY_VERSION >= 4 && defined __x86_64__ && defined __AVX512F__
+extern simd_float16 _simd_lgamma_f16(simd_float16 x);
+static inline SIMD_CFUNC simd_float16 __tg_lgamma(simd_float16 x) {
+  return _simd_lgamma_f16(x);
+}
+#else
+static inline SIMD_CFUNC simd_float16 __tg_lgamma(simd_float16 x) {
+  return simd_make_float16(__tg_lgamma(x.lo), __tg_lgamma(x.hi));
+}
+#endif
+
+#if SIMD_LIBRARY_VERSION >= 4
+extern simd_double2 _simd_lgamma_d2(simd_double2 x);
+static inline SIMD_CFUNC simd_double2 __tg_lgamma(simd_double2 x) {
+  return _simd_lgamma_d2(x);
+}
+#else
+static inline SIMD_CFUNC simd_double2 __tg_lgamma(simd_double2 x) {
+  return simd_make_double2(lgamma(x.x), lgamma(x.y));
+}
+#endif
+
+static inline SIMD_CFUNC simd_double3 __tg_lgamma(simd_double3 x) {
+  return simd_make_double3(__tg_lgamma(simd_make_double4(x)));
+}
+
+#if SIMD_LIBRARY_VERSION >= 4 && defined __x86_64__ && defined __AVX2__
+extern simd_double4 _simd_lgamma_d4(simd_double4 x);
+static inline SIMD_CFUNC simd_double4 __tg_lgamma(simd_double4 x) {
+  return _simd_lgamma_d4(x);
+}
+#else
+static inline SIMD_CFUNC simd_double4 __tg_lgamma(simd_double4 x) {
+  return simd_make_double4(__tg_lgamma(x.lo), __tg_lgamma(x.hi));
+}
+#endif
+
+#if SIMD_LIBRARY_VERSION >= 4 && defined __x86_64__ && defined __AVX512F__
+extern simd_double8 _simd_lgamma_d8(simd_double8 x);
+static inline SIMD_CFUNC simd_double8 __tg_lgamma(simd_double8 x) {
+  return _simd_lgamma_d8(x);
+}
+#else
+static inline SIMD_CFUNC simd_double8 __tg_lgamma(simd_double8 x) {
+  return simd_make_double8(__tg_lgamma(x.lo), __tg_lgamma(x.hi));
+}
+#endif
+
 static inline SIMD_CFUNC simd_float2 __tg_fdim(simd_float2 x, simd_float2 y) { return simd_bitselect(x-y, 0, x<y); }
 static inline SIMD_CFUNC simd_float3 __tg_fdim(simd_float3 x, simd_float3 y) { return simd_bitselect(x-y, 0, x<y); }
 static inline SIMD_CFUNC simd_float4 __tg_fdim(simd_float4 x, simd_float4 y) { return simd_bitselect(x-y, 0, x<y); }
@@ -5286,7 +5903,7 @@ static inline SIMD_CFUNC simd_float8 __tg_fma(simd_float8 x, simd_float8 y, simd
 }
 
 static inline SIMD_CFUNC simd_float16 __tg_fma(simd_float16 x, simd_float16 y, simd_float16 z) {
-#if defined __AVX512F__
+#if defined __x86_64__ && defined __AVX512F__
   return _mm512_fmadd_ps(x, y, z);
 #else
   return simd_make_float16(__tg_fma(x.lo, y.lo, z.lo), __tg_fma(x.hi, y.hi, z.hi));
@@ -5321,7 +5938,7 @@ static inline SIMD_CFUNC simd_double4 __tg_fma(simd_double4 x, simd_double4 y, s
 }
 
 static inline SIMD_CFUNC simd_double8 __tg_fma(simd_double8 x, simd_double8 y, simd_double8 z) {
-#if defined __AVX512F__
+#if defined __x86_64__ && defined __AVX512F__
   return _mm512_fmadd_pd(x, y, z);
 #else
   return simd_make_double8(__tg_fma(x.lo, y.lo, z.lo), __tg_fma(x.hi, y.hi, z.hi));
diff --git a/lib/libc/include/x86_64-macos.10-none/stdio.h b/lib/libc/include/any-macos.13-any/stdio.h
similarity index 92%
rename from lib/libc/include/x86_64-macos.10-none/stdio.h
rename to lib/libc/include/any-macos.13-any/stdio.h
index 0a756d415d..aec8472e70 100644
--- a/lib/libc/include/x86_64-macos.10-none/stdio.h
+++ b/lib/libc/include/any-macos.13-any/stdio.h
@@ -165,7 +165,12 @@ long	 ftell(FILE *);
 size_t	 fwrite(const void * __restrict __ptr, size_t __size, size_t __nitems, FILE * __restrict __stream) __DARWIN_ALIAS(fwrite);
 int	 getc(FILE *);
 int	 getchar(void);
+
+#if !defined(_POSIX_C_SOURCE)
+__deprecated_msg("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of gets(3), it is highly recommended that you use fgets(3) instead.")
+#endif
 char	*gets(char *);
+
 void	 perror(const char *) __cold;
 int	 printf(const char * __restrict, ...) __printflike(1, 2);
 int	 putc(int, FILE *);
@@ -177,7 +182,13 @@ void	 rewind(FILE *);
 int	 scanf(const char * __restrict, ...) __scanflike(1, 2);
 void	 setbuf(FILE * __restrict, char * __restrict);
 int	 setvbuf(FILE * __restrict, char * __restrict, int, size_t);
-int	 sprintf(char * __restrict, const char * __restrict, ...) __printflike(2, 3) __swift_unavailable("Use snprintf instead.");
+
+__swift_unavailable("Use snprintf instead.")
+#if !defined(_POSIX_C_SOURCE)
+__deprecated_msg("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of sprintf(3), it is highly recommended that you use snprintf(3) instead.")
+#endif
+int	 sprintf(char * __restrict, const char * __restrict, ...) __printflike(2, 3);
+
 int	 sscanf(const char * __restrict, const char * __restrict, ...) __scanflike(2, 3);
 FILE	*tmpfile(void);
 
@@ -186,10 +197,16 @@ __swift_unavailable("Use mkstemp(3) instead.")
 __deprecated_msg("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of tmpnam(3), it is highly recommended that you use mkstemp(3) instead.")
 #endif
 char	*tmpnam(char *);
+
 int	 ungetc(int, FILE *);
 int	 vfprintf(FILE * __restrict, const char * __restrict, va_list) __printflike(2, 0);
 int	 vprintf(const char * __restrict, va_list) __printflike(1, 0);
-int	 vsprintf(char * __restrict, const char * __restrict, va_list) __printflike(2, 0) __swift_unavailable("Use vsnprintf instead.");
+
+__swift_unavailable("Use vsnprintf instead.")
+#if !defined(_POSIX_C_SOURCE)
+__deprecated_msg("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of sprintf(3), it is highly recommended that you use vsnprintf(3) instead.")
+#endif
+int	 vsprintf(char * __restrict, const char * __restrict, va_list) __printflike(2, 0);
 __END_DECLS
 
 
@@ -217,25 +234,18 @@ __END_DECLS
 /* Additional functionality provided by:
  * POSIX.2-1992 C Language Binding Option
  */
-#if TARGET_OS_EMBEDDED
-#define __swift_unavailable_on(osx_msg, ios_msg) __swift_unavailable(ios_msg)
-#else
-#define __swift_unavailable_on(osx_msg, ios_msg) __swift_unavailable(osx_msg)
-#endif
 
 #if __DARWIN_C_LEVEL >= 199209L
 __BEGIN_DECLS
-int	 pclose(FILE *) __swift_unavailable_on("Use posix_spawn APIs or NSTask instead.", "Process spawning is unavailable.");
+int	 pclose(FILE *) __swift_unavailable("Use posix_spawn APIs or NSTask instead. (On iOS, process spawning is unavailable.)");
 #if defined(_DARWIN_UNLIMITED_STREAMS) || defined(_DARWIN_C_SOURCE)
-FILE	*popen(const char *, const char *) __DARWIN_ALIAS_STARTING(__MAC_10_6, __IPHONE_3_2, __DARWIN_EXTSN(popen)) __swift_unavailable_on("Use posix_spawn APIs or NSTask instead.", "Process spawning is unavailable.");
+FILE	*popen(const char *, const char *) __DARWIN_ALIAS_STARTING(__MAC_10_6, __IPHONE_3_2, __DARWIN_EXTSN(popen)) __swift_unavailable("Use posix_spawn APIs or NSTask instead. (On iOS, process spawning is unavailable.)");
 #else /* !_DARWIN_UNLIMITED_STREAMS && !_DARWIN_C_SOURCE */
-FILE	*popen(const char *, const char *) __DARWIN_ALIAS_STARTING(__MAC_10_6, __IPHONE_2_0, __DARWIN_ALIAS(popen)) __swift_unavailable_on("Use posix_spawn APIs or NSTask instead.", "Process spawning is unavailable.");
+FILE	*popen(const char *, const char *) __DARWIN_ALIAS_STARTING(__MAC_10_6, __IPHONE_2_0, __DARWIN_ALIAS(popen)) __swift_unavailable("Use posix_spawn APIs or NSTask instead. (On iOS, process spawning is unavailable.)");
 #endif /* (DARWIN_UNLIMITED_STREAMS || _DARWIN_C_SOURCE) */
 __END_DECLS
 #endif /* __DARWIN_C_LEVEL >= 199209L */
 
-#undef __swift_unavailable_on
-
 /* Additional functionality provided by:
  * POSIX.1c-1995,
  * POSIX.1i-1995,
@@ -370,12 +380,11 @@ extern __const char *__const sys_errlist[];
 int	 asprintf(char ** __restrict, const char * __restrict, ...) __printflike(2, 3);
 char	*ctermid_r(char *);
 char	*fgetln(FILE *, size_t *);
-__const char *fmtcheck(const char *, const char *);
+__const char *fmtcheck(const char *, const char *) __attribute__((format_arg(2)));
 int	 fpurge(FILE *);
 void	 setbuffer(FILE *, char *, int);
 int	 setlinebuf(FILE *);
 int	 vasprintf(char ** __restrict, const char * __restrict, va_list) __printflike(2, 0);
-FILE	*zopen(const char *, const char *, int);
 
 
 /*
diff --git a/lib/libc/include/x86_64-macos.10-none/stdlib.h b/lib/libc/include/any-macos.13-any/stdlib.h
similarity index 94%
rename from lib/libc/include/x86_64-macos.10-none/stdlib.h
rename to lib/libc/include/any-macos.13-any/stdlib.h
index a5b61930fd..24eab305a4 100644
--- a/lib/libc/include/x86_64-macos.10-none/stdlib.h
+++ b/lib/libc/include/any-macos.13-any/stdlib.h
@@ -178,18 +178,11 @@ unsigned long long
 	 strtoull(const char *__str, char **__endptr, int __base);
 #endif /* !__DARWIN_NO_LONG_LONG */
 
-#if TARGET_OS_EMBEDDED
-#define __swift_unavailable_on(osx_msg, ios_msg) __swift_unavailable(ios_msg)
-#else
-#define __swift_unavailable_on(osx_msg, ios_msg) __swift_unavailable(osx_msg)
-#endif
-
-__swift_unavailable_on("Use posix_spawn APIs or NSTask instead.", "Process spawning is unavailable")
+__swift_unavailable("Use posix_spawn APIs or NSTask instead. (On iOS, process spawning is unavailable.)")
 __API_AVAILABLE(macos(10.0)) __IOS_PROHIBITED
 __WATCHOS_PROHIBITED __TVOS_PROHIBITED
 int	 system(const char *) __DARWIN_ALIAS_C(system);
 
-#undef __swift_unavailable_on
 
 size_t	 wcstombs(char * __restrict, const wchar_t * __restrict, size_t);
 int	 wctomb(char *, wchar_t);
@@ -213,6 +206,9 @@ long	 jrand48(unsigned short[3]) __swift_unavailable("Use arc4random instead.");
 char	*l64a(long);
 void	 lcong48(unsigned short[7]);
 long	 lrand48(void) __swift_unavailable("Use arc4random instead.");
+#if !defined(_POSIX_C_SOURCE)
+__deprecated_msg("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of mktemp(3), it is highly recommended that you use mkstemp(3) instead.")
+#endif
 char	*mktemp(char *);
 int	 mkstemp(char *);
 long	 mrand48(void) __swift_unavailable("Use arc4random instead.");
@@ -273,8 +269,17 @@ uint32_t
 	 arc4random_uniform(uint32_t __upper_bound) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
 #ifdef __BLOCKS__
 int	 atexit_b(void (^ _Nonnull)(void)) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
+
+#ifdef __BLOCKS__
+#if __has_attribute(noescape)
+#define __bsearch_noescape __attribute__((__noescape__))
+#else
+#define __bsearch_noescape
+#endif
+#endif /* __BLOCKS__ */
 void	*bsearch_b(const void *__key, const void *__base, size_t __nel,
-	    size_t __width, int (^ _Nonnull __compar)(const void *, const void *)) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
+	    size_t __width, int (^ _Nonnull __compar)(const void *, const void *) __bsearch_noescape)
+	    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);
 #endif /* __BLOCKS__ */
 
 	 /* getcap(3) functions */
@@ -347,6 +352,9 @@ int	 sradixsort(const unsigned char **__base, int __nel, const unsigned char *__
 void	 sranddev(void);
 void	 srandomdev(void);
 void	*reallocf(void *__ptr, size_t __size) __alloc_size(2);
+long long
+	strtonum(const char *__numstr, long long __minval, long long __maxval, const char **__errstrp)
+	__API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0));
 #if !__DARWIN_NO_LONG_LONG
 long long
 	 strtoq(const char *__str, char **__endptr, int __base);
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/_symbol_aliasing.h b/lib/libc/include/any-macos.13-any/sys/_symbol_aliasing.h
similarity index 78%
rename from lib/libc/include/x86_64-macos.10-none/sys/_symbol_aliasing.h
rename to lib/libc/include/any-macos.13-any/sys/_symbol_aliasing.h
index 17b4d6fe37..6d0429add1 100644
--- a/lib/libc/include/x86_64-macos.10-none/sys/_symbol_aliasing.h
+++ b/lib/libc/include/any-macos.13-any/sys/_symbol_aliasing.h
@@ -305,6 +305,84 @@
 #define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_6(x)
 #endif
 
+#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130700
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_7(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_13_7(x)
+#endif
+
+#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 140000
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_14_0(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_14_0(x)
+#endif
+
+#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 140100
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_14_1(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_14_1(x)
+#endif
+
+#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 140200
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_14_2(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_14_2(x)
+#endif
+
+#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 140300
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_14_3(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_14_3(x)
+#endif
+
+#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 140500
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_14_5(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_14_5(x)
+#endif
+
+#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 150000
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_15_0(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_15_0(x)
+#endif
+
+#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 150100
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_15_1(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_15_1(x)
+#endif
+
+#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 150200
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_15_2(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_15_2(x)
+#endif
+
+#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 150300
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_15_3(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_15_3(x)
+#endif
+
+#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 150400
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_15_4(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_15_4(x)
+#endif
+
+#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 160000
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_16_0(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_16_0(x)
+#endif
+
+#if defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 160100
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_16_1(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_IPHONE___IPHONE_16_1(x)
+#endif
+
 #if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1000
 #define __DARWIN_ALIAS_STARTING_MAC___MAC_10_0(x) x
 #else
@@ -495,4 +573,64 @@
 #define __DARWIN_ALIAS_STARTING_MAC___MAC_10_15_1(x) x
 #else
 #define __DARWIN_ALIAS_STARTING_MAC___MAC_10_15_1(x)
+#endif
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101504
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_15_4(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_15_4(x)
+#endif
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101600
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_16(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_10_16(x)
+#endif
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 110000
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_11_0(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_11_0(x)
+#endif
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 110100
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_11_1(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_11_1(x)
+#endif
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 110300
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_11_3(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_11_3(x)
+#endif
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 120000
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_12_0(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_12_0(x)
+#endif
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 120100
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_12_1(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_12_1(x)
+#endif
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 120200
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_12_2(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_12_2(x)
+#endif
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 120300
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_12_3(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_12_3(x)
+#endif
+
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 130000
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_13_0(x) x
+#else
+#define __DARWIN_ALIAS_STARTING_MAC___MAC_13_0(x)
 #endif
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/sys/_types/_graftdmg_un.h b/lib/libc/include/any-macos.13-any/sys/_types/_graftdmg_un.h
new file mode 100644
index 0000000000..12282c994b
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/sys/_types/_graftdmg_un.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2021-22 Apple Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+#ifndef _GRAFTDMG_UN_
+#define _GRAFTDMG_UN_
+
+#include <sys/_types/_u_int8_t.h>
+#include <sys/_types/_u_int64_t.h>
+#include <sys/_types/_u_int32_t.h>
+
+#define GRAFTDMG_SECURE_BOOT_CRYPTEX_ARGS_VERSION 1
+#define MAX_GRAFT_ARGS_SIZE 512
+
+/* Flag values for secure_boot_cryptex_args.sbc_flags */
+#define SBC_PRESERVE_MOUNT              0x0001  /* Preserve underlying mount until shutdown */
+#define SBC_ALTERNATE_SHARED_REGION     0x0002  /* Binaries within should use alternate shared region */
+#define SBC_SYSTEM_CONTENT              0x0004  /* Cryptex contains system content */
+#define SBC_PANIC_ON_AUTHFAIL           0x0008  /* On failure to authenticate, panic */
+#define SBC_STRICT_AUTH                 0x0010  /* Strict authentication mode */
+#define SBC_PRESERVE_GRAFT              0x0020  /* Preserve graft itself until unmount */
+
+typedef struct secure_boot_cryptex_args {
+	u_int32_t sbc_version;
+	u_int32_t sbc_4cc;
+	int sbc_authentic_manifest_fd;
+	int sbc_user_manifest_fd;
+	int sbc_payload_fd;
+	u_int64_t sbc_flags;
+} __attribute__((aligned(4), packed))  secure_boot_cryptex_args_t;
+
+typedef union graft_args {
+	u_int8_t max_size[MAX_GRAFT_ARGS_SIZE];
+	secure_boot_cryptex_args_t sbc_args;
+} graftdmg_args_un;
+
+#endif /* _GRAFTDMG_UN_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/cdefs.h b/lib/libc/include/any-macos.13-any/sys/cdefs.h
similarity index 86%
rename from lib/libc/include/x86_64-macos.10-none/sys/cdefs.h
rename to lib/libc/include/any-macos.13-any/sys/cdefs.h
index b2b091e28e..40afbe5424 100644
--- a/lib/libc/include/x86_64-macos.10-none/sys/cdefs.h
+++ b/lib/libc/include/any-macos.13-any/sys/cdefs.h
@@ -152,8 +152,16 @@
 #endif /* !NO_ANSI_KEYWORDS */
 #endif /* !(__STDC__ || __cplusplus) */
 
+/*
+ * __pure2 can be used for functions that are only a function of their scalar
+ * arguments (meaning they can't dereference pointers).
+ *
+ * __stateful_pure can be used for functions that have no side effects,
+ * but depend on the state of the memory.
+ */
 #define __dead2         __attribute__((__noreturn__))
 #define __pure2         __attribute__((__const__))
+#define __stateful_pure __attribute__((__pure__))
 
 /* __unused denotes variables and functions that may not be used, preventing
  * the compiler from warning about it if not used.
@@ -174,6 +182,22 @@
 #define __cold
 #endif
 
+/* __returns_nonnull marks functions that return a non-null pointer. */
+#if __has_attribute(returns_nonnull)
+#define __returns_nonnull __attribute((returns_nonnull))
+#else
+#define __returns_nonnull
+#endif
+
+/* __exported denotes symbols that should be exported even when symbols
+ * are hidden by default.
+ * __exported_push/_exported_pop are pragmas used to delimit a range of
+ *  symbols that should be exported even when symbols are hidden by default.
+ */
+#define __exported      __attribute__((__visibility__("default")))
+#define __exported_push _Pragma("GCC visibility push(default)")
+#define __exported_pop  _Pragma("GCC visibility pop")
+
 /* __deprecated causes the compiler to produce a warning when encountering
  * code using the deprecated functionality.
  * __deprecated_msg() does the same, and compilers that support it will print
@@ -202,9 +226,17 @@
 #define __kpi_deprecated(_msg)
 
 /* __unavailable causes the compiler to error out when encountering
- * code using the tagged function of variable.
+ * code using the tagged function
  */
-#define __unavailable   __attribute__((__unavailable__))
+#if __has_attribute(unavailable)
+#define __unavailable __attribute__((__unavailable__))
+#else
+#define __unavailable
+#endif
+
+#define __kpi_unavailable
+
+#define __kpi_deprecated_arm64_macos_unavailable
 
 /* Delete pseudo-keywords wherever they are not available or needed. */
 #ifndef __dead
@@ -370,11 +402,13 @@
  * types.
  */
 #define __printflike(fmtarg, firstvararg) \
-	        __attribute__((__format__ (__printf__, fmtarg, firstvararg)))
+	__attribute__((__format__ (__printf__, fmtarg, firstvararg)))
 #define __printf0like(fmtarg, firstvararg) \
-	        __attribute__((__format__ (__printf0__, fmtarg, firstvararg)))
+	__attribute__((__format__ (__printf0__, fmtarg, firstvararg)))
 #define __scanflike(fmtarg, firstvararg) \
-	        __attribute__((__format__ (__scanf__, fmtarg, firstvararg)))
+	__attribute__((__format__ (__scanf__, fmtarg, firstvararg)))
+#define __osloglike(fmtarg, firstvararg) \
+	__attribute__((__format__ (__os_log__, fmtarg, firstvararg)))
 
 #define __IDSTRING(name, string) static const char name[] __used = string
 
@@ -471,9 +505,19 @@
 
 /* These settings are particular to each product. */
 /* Platform: MacOSX */
+#if defined(__i386__)
 #define __DARWIN_ONLY_64_BIT_INO_T      0
-/* #undef __DARWIN_ONLY_UNIX_CONFORMANCE (automatically set for 64-bit) */
+#define __DARWIN_ONLY_UNIX_CONFORMANCE  0
 #define __DARWIN_ONLY_VERS_1050         0
+#elif defined(__x86_64__)
+#define __DARWIN_ONLY_64_BIT_INO_T      0
+#define __DARWIN_ONLY_UNIX_CONFORMANCE  1
+#define __DARWIN_ONLY_VERS_1050         0
+#else
+#define __DARWIN_ONLY_64_BIT_INO_T      1
+#define __DARWIN_ONLY_UNIX_CONFORMANCE  1
+#define __DARWIN_ONLY_VERS_1050         1
+#endif
 
 /*
  * The __DARWIN_ALIAS macros are used to do symbol renaming; they allow
@@ -493,14 +537,6 @@
  * pre-10.5, and it is the default compilation environment, revert the
  * compilation environment to pre-__DARWIN_UNIX03.
  */
-#if !defined(__DARWIN_ONLY_UNIX_CONFORMANCE)
-#  if defined(__LP64__)
-#    define __DARWIN_ONLY_UNIX_CONFORMANCE 1
-#  else /* !__LP64__ */
-#    define __DARWIN_ONLY_UNIX_CONFORMANCE 0
-#  endif /* __LP64__ */
-#endif /* !__DARWIN_ONLY_UNIX_CONFORMANCE */
-
 #if !defined(__DARWIN_UNIX03)
 #  if   __DARWIN_ONLY_UNIX_CONFORMANCE
 #    if defined(_NONSTD_SOURCE)
@@ -787,7 +823,19 @@
  * catastrophic run-time failures.
  */
 #ifndef __CAST_AWAY_QUALIFIER
-#define __CAST_AWAY_QUALIFIER(variable, qualifier, type)  (type) (long)(variable)
+/*
+ * XXX: this shouldn't ignore anything more than -Wcast-qual,
+ * but the old implementation made it an almighty cast that
+ * ignored everything, so things break left and right if you
+ * make it only ignore -Wcast-qual.
+ */
+#define __CAST_AWAY_QUALIFIER(variable, qualifier, type) \
+	_Pragma("GCC diagnostic push") \
+	_Pragma("GCC diagnostic ignored \"-Wcast-qual\"") \
+	_Pragma("GCC diagnostic ignored \"-Wcast-align\"") \
+	_Pragma("GCC diagnostic ignored \"-Waddress-of-packed-member\"") \
+	((type)(variable)) \
+	_Pragma("GCC diagnostic pop")
 #endif
 
 /*
@@ -798,11 +846,69 @@
 #define __XNU_PRIVATE_EXTERN __attribute__((visibility("hidden")))
 #endif
 
+#if __has_include(<ptrcheck.h>)
+#include <ptrcheck.h>
+#else
+/*
+ * We intentionally define to nothing pointer attributes which do not have an
+ * impact on the ABI. __indexable and __bidi_indexable are not defined because
+ * of the ABI incompatibility that makes the diagnostic preferable.
+ */
+#define __has_ptrcheck 0
+#define __single
+#define __unsafe_indexable
+#define __counted_by(N)
+#define __sized_by(N)
+#define __ended_by(E)
+#define __terminated_by(T)
+#define __null_terminated
+
+/*
+ * Similarly, we intentionally define to nothing the
+ * __ptrcheck_abi_assume_single and __ptrcheck_abi_assume_unsafe_indexable
+ * macros because they do not lead to an ABI incompatibility. However, we do not
+ * define the indexable and unsafe_indexable ones because the diagnostic is
+ * better than the silent ABI break.
+ */
+#define __ptrcheck_abi_assume_single()
+#define __ptrcheck_abi_assume_unsafe_indexable()
+
+/* __unsafe_forge intrinsics are defined as regular C casts. */
+#define __unsafe_forge_bidi_indexable(T, P, S) ((T)(P))
+#define __unsafe_forge_single(T, P) ((T)(P))
+#define __terminated_by_to_indexable(P) (P)
+#define __unsafe_terminated_by_to_indexable(P) (P)
+#define __null_terminated_to_indexable(P) (P)
+#define __unsafe_null_terminated_to_indexable(P) (P)
+#define __unsafe_terminated_by_from_indexable(T, P, ...) (P)
+#define __unsafe_null_terminated_from_indexable(P, ...) (P)
+
+/* decay operates normally; attribute is meaningless without pointer checks. */
+#define __array_decay_dicards_count_in_parameters
+
+/* this is a write-once variable; not useful without pointer checks. */
+#define __unsafe_late_const
+#endif /* !__has_include(<ptrcheck.h>) */
+
+
+#define __ASSUME_PTR_ABI_SINGLE_BEGIN       __ptrcheck_abi_assume_single()
+#define __ASSUME_PTR_ABI_SINGLE_END         __ptrcheck_abi_assume_unsafe_indexable()
+
+#if __has_ptrcheck
+#define __header_indexable                  __indexable
+#define __header_bidi_indexable             __bidi_indexable
+#else
+#define __header_indexable
+#define __header_bidi_indexable
+#endif
+
 /*
  * Architecture validation for current SDK
  */
 #if !defined(__sys_cdefs_arch_unknown__) && defined(__i386__)
 #elif !defined(__sys_cdefs_arch_unknown__) && defined(__x86_64__)
+#elif !defined(__sys_cdefs_arch_unknown__) && defined(__arm__)
+#elif !defined(__sys_cdefs_arch_unknown__) && defined(__arm64__)
 #else
 #error Unsupported architecture
 #endif
@@ -852,4 +958,12 @@
 	        typedef _type _name; enum __VA_ARGS__ __enum_closed __enum_options
 #endif
 
+
+
+#define __kernel_ptr_semantics
+#define __kernel_data_semantics
+#define __kernel_dual_semantics
+
+
+
 #endif /* !_CDEFS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/random.h b/lib/libc/include/any-macos.13-any/sys/clonefile.h
similarity index 57%
rename from lib/libc/include/x86_64-macos.10-none/sys/random.h
rename to lib/libc/include/any-macos.13-any/sys/clonefile.h
index 4599da090b..faaf3a0802 100644
--- a/lib/libc/include/x86_64-macos.10-none/sys/random.h
+++ b/lib/libc/include/any-macos.13-any/sys/clonefile.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2000-2005 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2015-2017 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -26,15 +26,29 @@
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
 
-#ifndef __SYS_RANDOM_H__
-#define __SYS_RANDOM_H__
+#ifndef _SYS_CLONEFILE_H_
+#define _SYS_CLONEFILE_H_
+
+/* Options for clonefile calls */
+#define CLONE_NOFOLLOW      0x0001     /* Don't follow symbolic links */
+#define CLONE_NOOWNERCOPY   0x0002     /* Don't copy ownership information from source */
+#define CLONE_ACL           0x0004     /* Copy access control lists from source */
+
 
-#include <sys/appleapiopts.h>
 #include <sys/cdefs.h>
+#include <machine/_types.h>
+#include <_types/_uint32_t.h>
+#include <Availability.h>
 
 __BEGIN_DECLS
-    __OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0) __TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0)
-int getentropy(void* buffer, size_t size);
+
+int clonefileat(int, const char *, int, const char *, uint32_t) __OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0) __TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0);
+
+int fclonefileat(int, int, const char *, uint32_t) __OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0) __TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0);
+
+int clonefile(const char *, const char *, uint32_t) __OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0) __TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0);
+
 __END_DECLS
 
-#endif /* __SYS_RANDOM_H__ */
\ No newline at end of file
+
+#endif /* _SYS_CLONEFILE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/sys/constrained_ctypes.h b/lib/libc/include/any-macos.13-any/sys/constrained_ctypes.h
new file mode 100644
index 0000000000..da3aaff482
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/sys/constrained_ctypes.h
@@ -0,0 +1,591 @@
+/*
+ * Copyright (c) 2000-2022 Apple Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+
+#ifndef __CONSTRAINED_CTYPES__
+#define __CONSTRAINED_CTYPES__
+
+#include <sys/cdefs.h>
+
+/* This file introduces macros for constraining pointer
+ * types to specific contracts:
+ *
+ *
+ * 1. List of supported constrained pointers.
+ *
+ * 1.1. `Reference' pointers.
+ *
+ *      The `reference' pointers point to a single entity. The pointer
+ *      arithmetics are not supported for the `reference' pointers.
+ *
+ *      The `reference' pointers are fully ABI compatible with
+ *      the unconstrained C pointers.
+ *
+ *      The naming convention for the `reference' pointers uses
+ *      the `ref' constraint tag. See `Naming conventions' below for furhter
+ *      discussion.
+ *
+ *      Examples:
+ *
+ *      (1) `socket_ref_t' is `reference' pointer to `struct socket'.
+ *      (2) `uint32_ref_t' is `reference' pointer to `uint32_t'.
+ *
+ *
+ * 1.2. `Checked' pointers.
+ *
+ *      The `checked' pointers represent contigous data arrays, which
+ *      can be traversed only in the direction of increasing memory addresses.
+ *      The pointer arithmetics are partially supported: decrements (p--, --p)
+ *      are disallowed.
+ *
+ *      The `checked' pointers are not ABI-compatible with plain C pointers,
+ *      due to the boundary checks instrumentation. See `ABI
+ *      Compatibility Considerations' below for further discussion.
+ *
+ *      The naming convention for the `checked' pointers uses the `ptr'
+ *      constraint tag. See `Naming conventions' below for furhter discussion.
+ *
+ *      Examples:
+ *
+ *      (1) `socket_ptr_t' is `checked' pointer to `struct socket'.
+ *      (2) `uint32_ptr_t' is `checked' pointer to `uint32_t'.
+ *
+ *
+ * 1.3. `Bidirectional' pointers.
+ *
+ *      The `bidirectional' pointers represent contigous data arrays,
+ *      which can be traversed in both directions. The pointer arithmetics are
+ *      fully supported for the `array' pointers.
+ *
+ *      The `bidirectional' pointers are not ABI-compatible with plain C
+ *      pointers, due to the boundary checks instrumentation. Additionally,
+ *      passing `bidirectional' pointers to functions require the use of stack.
+ *      See `ABI Compatibility Considerations' below for further discussion.
+ *
+ *      The naming convention for the `bidirectional' pointers uses
+ *      the `bptr' constraint tag. See `Naming conventions' below for furhter
+ *      discussion.
+ *
+ *      Examples:
+ *
+ *      (1) `socket_bptr_t' is `bidirectional' pointer to `struct socket'.
+ *      (2) `uint32_bptr_t' is `bidirectional' pointer to `uint32_t'.
+ *
+ *
+ * 1.4. Multidimensional constrained pointers.
+ *
+ *      Constraining multidimensional pointers is achieved by iteratively
+ *      applying the constraints from the innermost type to the outermost type.
+ *
+ *      Pointer arithmetics are supported for the dimensions that
+ *      are not constrained to a `reference' or `const reference'.
+ *
+ *      If any of the dimension constraints isn't ABI-compatible with its
+ *      unconstrained counterpart, then the entire constrained multidimensional
+ *      pointer is not ABI-compatible with the corresponding unconstrained
+ *      multidimensional pointer. Otherwise, the two are ABI-compatible. See
+ *      `ABI compatibility' below for further discussion.
+ *
+ *      The naming convention for the multidimensional constrained pointers
+ *      combines the naming tags that correspond to the individual constraints.
+ *      See `Naming conventions' below for furhter discussion.
+ *
+ *      Examples:
+ *
+ *      (1) `socket_ref_bptr_t' is a `bidirectional' pointer to a `reference'
+ *          pointer to `struct socket'.
+ *      (2) `socket_ptr_ref_t' is a `reference' pointer to a `checked'
+ *          pointer to `struct socket'.
+ *
+ *
+ * 1.5. Using `const', `volatile', and `restrict' type qualifiers with
+ *      constrained types.
+ *
+ *      The use of the `const', `volatile', and `restrict' type qualifiers
+ *      (a.k.a. "CRV qualifiers") follows the syntax of the C language.
+ *
+ *      As a special case, if a `const' qualifier is applied to inner
+ *      dimensions of a multidimensional constrained pointer type, the
+ *      constraint tag is prepended with letter `c'; thus `cref' can be used
+ *      for const-qualified `reference' pointer. This abbreviation is only
+ *      supported for the `const' qualifier, as use of `volatile' or `restrict'
+ *      for inner constrained types is quite uncommon. See `Multidimensional
+ *      constrained pointers' above and `Naming conventions' below for further
+ *      discussion.
+ *
+ *      Examples:
+ *
+ *      (1) `socket_ref_t const' is the const-qualified `reference' pointer
+ *          to `struct socket'.
+ *      (2) `socket_ptr_t volatile' is the volatile-qualified `checked' pointer
+ *          to `struct socket'.
+ *      (3) `socket_ptr_ref_t const' is a const-qualified `reference' pointer
+ *          to a `checked' pointer to `struct socket'.
+ *      (4) `socket_cref_ptr_t const' is a `checked' pointer to a
+ *          const-qualified `reference' pointer to `struct socket'.
+ *
+ *
+ * 1.6. Combining constrained pointers and unconstrained pointers.
+ *
+ *      Unconstrained pointers to constrained pointers follow
+ *      the standard C syntax. Defining constrained pointers to
+ *      unconstrained pointers is possible via defining a constrained pointer
+ *      to a typedef.
+ *
+ *      Examples:
+ *
+ *      (1) `socket_ref_t *' is an unconstrained pointer to `socket_ref_t', i.e.
+ *          unconstrained pointer to a `reference' pointer to `struct socket'.
+ *      (2) `socket_ref_t const *' is an unconstrained pointer to `socket_ref_t const',
+ *          i.e. an unconstrained pointer to a const-qualified `reference'
+ *          pointer to `struct socket'.
+ *      (3) `socket_ref_t * const' is a const-qualified unconstrained pointer to
+ *          `socket_ref_t', i.e. a const-qualified unconstrained pointer to a
+ *          `reference' pointer to `struct socket'.
+ *      (4) `intptr_ref_t' is a `reference' pointer to `intptr_t', i.e.
+ *          a `reference' pointer to an unconstrained pointer to `int'. Note
+ *          the use of `intptr_t' typedef, which is necessary at the moment.
+ *
+ *
+ * 2. Defining constrained pointer types.
+ *
+ * 2.1. Declaring multiple constrained types simultaneously.
+ *
+ *      `__CCT_DECLARE_CONSTRAINED_PTR_TYPES(basetype, basetag)`
+ *      is the suggested way to declare constrained pointer types.
+ *
+ *      Parameters:
+ *
+ *      `basetype`: the pointee type, including `struct' or `enum' keywords.
+ *      `basetag`:  the prefix of the constrained type.
+ *
+ *      This macro acts differently in the user-space and the kernel-space
+ *      code. When used in the former, it will only declare types which are
+ *      ABI-safe. See `ABI Compatibility Considerations' below for more details.
+ *
+ *      Examples:
+ *
+ *      (1) When used from the user space,
+ *          `__CCT_DECLARE_CONSTRAINED_PTR_TYPES(struct socket, socket);'
+ *           will declare types:
+ *
+ *          (a) `socket_ref_t': the `reference' to `struct socket'
+ *          (b) `socket_ref_ref_t': the `reference to reference'
+ *              to `struct socket'.
+ *
+ *      (2) When used from the kernel space,
+ *          `__CCT_DECLARE_CONSTRAINED_PTR_TYPES(struct socket, socket);'
+ *           will declare the above types, plus:
+ *
+ *          (c) `socket_ptr_t': `checked' pointer to `struct socket'.
+ *          (d) `socket_bptr_t': `bidirectional' pointer to `struct socket'.
+ *          (e) `socket_ref_ptr_t': `checked' pointer to a `reference'
+ *              to `struct socket'.
+ *          (f) `socket_ptr_ref_t': `reference' to a `checked' pointer
+ *              to `struct socket'.
+ *
+ *      These additional types are not ABI-safe, and therefore are not exposed
+ *      to the user space. See `ABI Compatibility Considerations' below.
+ *
+ *
+ * 2.2. Declaring individual constrained types.
+ *
+ *      The above macro attempts to do many things at once, and under some
+ *      circumstances can be not appropriate. For these circumstances, a
+ *      finer-graned declarator can be used:
+ *
+ *      `__CCT_DECLARE_CONSTRAINED_PTR_TYPE(basetype, basetag, ...)'
+ *
+ *      Parameters:
+ *
+ *      `basetype`: the pointee type.
+ *      `basetag`:  the prefix of the constrained type.
+ *      `...`:      list of `REF', `CREF', `BPTR' or `PTR', which represent
+ *                  the desired constraints.
+ *
+ *      Examples:
+ *
+ *      (1) `__CCT_DECLARE_CONSTRAINED_PTR_TYPE(struct socket, socket, REF)'
+ *          will declare the type `socket_ref_t`:
+ *
+ *      (2) `__CCT_DECLARE_CONSTRAINED_PTR_TYPE(struct socket, socket, REF, PTR, REF)'
+ *           will declare the type `socket_ref_ptr_ref_t`:
+ *
+ *
+ * 3. Using constrained pointer types.
+ *
+ * 3.1. Using constrained pointers for local variables.
+ *
+ *      Constraining the pointers on the stack reduces the risk of stack
+ *      overflow. Therefore, it is highly suggested to use the constrained
+ *      versions of the pointers for stack parameters. For local array
+ *      variables, opt for the `bidirectional' pointers. If only a single value
+ *      needs to be pointed, opt for the `reference' pointers.
+ *
+ *      There are two alternative approaches for using the `reference' pointers.
+ *      One approach is to explicitly use `thing_ref_t ptr` instead of `thing *ptr`.
+ *      The other approach is to surround the code with the directives
+ *      `__ASSUME_PTR_ABI_SINGLE_BEGIN' and `__ASSUME_PTR_ABI_SINGLE_END', which
+ *      will have the effect of turning every unconstrained pointer to its
+ *      `reference' counterpart.
+ *
+ *
+ * 3.2. Using constrained pointers for function parameters
+ *
+ * 3.2.1. Use `reference' pointers for scalar parameters.
+ *
+ *      Scalar parameters are safe to use across ABI boundaries.
+ *
+ *      Examples:
+ *
+ *      (1) Using `reference' pointers for scalar input:
+ *
+ *      errno_t thing_is_valid(const thing_ref_t t)
+ *      {
+ *              return t == NULL ? EINVAL : 0;
+ *      }
+ *
+ *
+ *      (2) Using `reference' pointers for scalar output, which is
+ *          allocated by the caller:
+ *
+ *      errno_t thing_copy(const thing_ref_t src, thing_ref_t dst)
+ *      {
+ *              if (src == NULL || dst == NULL) {
+ *                      return EINVAL;
+ *              }
+ *              bcopy(src, dst);
+ *              return 0;
+ *      }
+ *
+ *      (3) Using `reference to reference' for scalar output that is
+ *          allocated by the callee:
+ *
+ *      errno_t thing_dup(const thing_ref_t src, thing_ref_ref_t dst)
+ *      {
+ *              *dst = malloc(sizeof(*dst));
+ *              bcopy(src, *dst, sizeof(*src));
+ *              return 0;
+ *      }
+ *
+ *
+ * 3.2.2. Use `checked' pointers for vector parameters.
+ *
+ *      When the ABI isn't a concern, use of `checked' pointers
+ *      increases the code readability.
+ *
+ *      See `ABI Compatibility Considerations' below for vector parameters when
+ *      ABI is a concern.
+ *
+ *      Examples:
+ *
+ *      (1) Using `checked' pointers for vector input:
+ *
+ *      errno_t thing_find_best(const thing_ref_ptr_t things,
+ *                              thing_ref_ref_t best, size_t count)
+ *      {
+ *              for (int i = 0; i < count; i++) {
+ *                      if (thing_is_the_best(things[i])) {
+ *                              *best = things[i];
+ *                              return 0;
+ *                      }
+ *              }
+ *              return ENOENT; // no best thing
+ *      }
+ *
+ *      (2) Using `checked' pointers for vector output parameters that
+ *          are allocated by caller:
+ *
+ *      errno_t thing_copy_things(thing_ref_ptr_t src, thing_ref_ptr_t dst,
+ *                                size_t count)
+ *      {
+ *              for (int i = 0; i < count; i++) {
+ *                      dst[i] = malloc(sizeof(*dst[i]));
+ *                      bcopy(src[i], dst[i], sizeof(*src[i]));
+ *              }
+ *              return 0;
+ *      }
+ *
+ *      (3) Using `reference to checked' pointers for vector output
+ *      parameters that are allocated by callee:
+ *
+ *      errno_t thing_dup_things(thing_ref_ptr_t src, thing_ref_ptr_ref_t dst,
+ *                               size_t count)
+ *      {
+ *              *dst = malloc(sizeof(**src) * count);
+ *              return thing_copy_things(src, *dst, count);
+ *      }
+ *
+ *
+ * 3.3. Using constrained pointers in struct definitions
+ *
+ *      Examples:
+ *
+ *      (1) Using a structure that points to array of things:
+ *
+ *      struct things_crate {
+ *              size_t       tc_count;
+ *              thing_bptr_t tc_things;
+ *      };
+ *
+ *
+ * 3.4. Variable-size structures
+ *
+ *      Constrained pointer instrumentation depends on knowing the size of the
+ *      structures. If the structure contains a variable array, the array needs
+ *      to be annotated by `__sized_by' or `__counted_by' attribute:
+ *
+ *      Example:
+ *
+ *      struct sockaddr {
+ *              __uint8_t       sa_len;
+ *              sa_family_t     sa_family;
+ *              char            sa_data[__counted_by(sa_len - 2)];
+ *      };
+ *
+ *
+ * 4. ABI Compatibility Considerations
+ *
+ *      The pointer instrumentation process has ABI implications.
+ *
+ *      When the pointer insrumentation is enabled, the size of `bidirectional'
+ *      and `checked' pointers exceeds the size of the machine word.
+ *
+ *      Thus, if there is a concern that the instrumentation is enabled only in
+ *      some compilation units that use the function, these constrained
+ *      pointers can not be used for function parameters.
+ *
+ *      Instead, one should rely on `__counted_by(count)' or `__sized_by(size)'
+ *      attributes. These attributes accept as a parameter the name of a
+ *      variable that contains the cont of items, or the byte size, of the
+ *      pointed-to array. Use of these attributes does not change the size of
+ *      the pointer.
+ *
+ *      The tradeoff is between maintaining code readabilty and ABI compatibility.
+ *
+ *      A common pattern is to split the function into the implementation,
+ *      which is statically linked and therefore is ABI-safe, and the interface
+ *      wrapper, which uses `__counted_by' or `__sized_by' to preserve ABI
+ *      compatibility.
+ *
+ *
+ * 4.1. When ABI is a concern, replace `bidirectional' and `checked'
+ *        with  `__counted_by(count)` and `__sized_by(size)` for vector
+ *        parameters.
+ *
+ *
+ *      Examples:
+ *
+ *      (1) Using `const thing_ref_t __counted_by(count)' instead of `const
+ *          thing_ref_ptr_t' for vector input in a wrapper:
+ *
+ *      errno_t thing_find_best_compat(const thing_ref_t __counted_by(count)things,
+ *                                     thing_ref_ref_t best, size_t count)
+ *      {
+ *              // __counted_by implicitly upgraded to `checked'
+ *              return thing_find_best(things, best, count);
+ *      }
+ *
+ *      (2) Using `thing_ref_t __counted_by(count)' instead of `thing_ref_ptr_t'
+ *          for vector output in a wrapper.
+ *
+ *      errno_t thing_copy_things_compat(thing_ref_t __counted_by(count)src,
+ *                                       things_ref_t __counted_by(count)dst,
+ *                                       size_t count)
+ *      {
+ *              // __counted_by implicitly upgraded to `checked'
+ *              return thing_copy_things(src, dst, count);
+ *      }
+ *
+ *
+ * 4.2. When ABI is a concern, use `__counted_by(count)' and
+ *        `__sized_by(size)' for struct members that point to arrays.
+ *
+ *      Examples:
+ *
+ *      (1) Using a structure that points to array of things:
+ *
+ *      struct things_crate {
+ *              size_t                               tc_count;
+ *              struct thing * __counted_by(tc_count)tc_things;
+ *      };
+ *
+ * 5. Naming conventions
+ *
+ *      If `typename' is the name of a C type, and `tag' is a constraint tag
+ *      (one of `ref', `ptr', or `bptr'), then the name of a pointer to
+ *      `typename' constrained by `tag' is `basetag_tag_t', where `basename'
+ *      is defined by:
+ *
+ *      (a) If `typename' is a name of an integral type, then `basetag' is same
+ *          as `typename'.
+ *      (b) If `typename' is a name of a function type, then `basetag' is same
+ *          as `typename'.
+ *      (c) If `typename' is a name of a structure, then `basetag' is formed by
+ *          stripping the `struct' keyword from `typename'.
+ *      (d) If `typename' is a name of an enumeration, then `basetag' is formed
+ *          by stripping the `enum' keyword from `typename'.
+ *      (e) If `typename' is a name of a typedef to a struct or an enum that ends
+ *          with `_t', then `basetag' is formed by stripping the `_t' suffix
+ *          from `typename'. See (h) below for when `typename' is a pointer typedef.
+ *      (f) If `typename' is a name of constrained pointer type ending with `_t',
+ *          then `basetag' is formed by stripping the `_t' suffix from `typename'.
+ *
+ *      Additionally, constrained pointers to constrained const pointers are a
+ *      special case:
+ *
+ *      (g) If `typename' is a name of a constrained pointer type, ending with
+ *          `_{innertag}_t', and `typename' has `const' qualifier, then `basetag'
+ *          is formed by replacing `_{innertag}_t' with `_c{innertag}'
+ *
+ *      Finally, sometimes `name_t' represents not `struct name' but `struct name *'.
+ *      This creates additional special case:
+ *
+ *      (h) If `typename' is a pointer typedef named `{struct}_t`, such as
+ *          `mbuf_t',  then creating a constrained pointer to a `typename' would
+ *           require creating a  constrained pointer to an unconstrained pointer,
+ *           which is not supported at the moment. Instead, a constrained pointer to
+ *           `typeof(*typename)` must be created first, and constrained again. Using
+ *           the `mbuf_t` example, first one should create a constrained pointer to
+ *           `struct mbuf`, e.g, `mbuf_bptr_t`, and then constrain it again with
+ *           `tag`, leading to `mbuf_bptr_ref_t'.
+ *
+ *      Examples:
+ *
+ *      (1) `int_ref_t' is a `reference pointer' to `int', following the rule (a) above.
+ *      (2) `so_pru_ref_t' is a `reference pointer' to function `so_pru',
+ *          following the rule (b) above.
+ *      (3) `socket_ref_t' is a `reference pointer' to `struct socket',
+ *          following the rule (c) above.
+ *      (4) `classq_pkt_type_ref_t' is a `reference pointer' to `enum classq_pkt_type'
+ *          following the rule (d) above.
+ *      (5) `classq_pkt_type_ref_t' is a also `reference pointer' to `classq_pkt_type_t'
+ *          following the rule (e) above.
+ *      (6) `socket_ref_ref_t' is a `reference pointer' to `socket_ref_t`,
+ *          following the rule (f) above.
+ *      (7) `socket_cref_ref_t' is a `reference pointer' to `socket_ref_t const`,
+ *          following the rule (g) above.
+ *      (8) `mbuf_ref_ref_t', is a `reference pointer' to `mbuf_ref_t`, and is one
+ *          possible result of creating a `reference pointer' to `mbuf_t',
+ *          following the rule (h) above.
+ *      (9) `mbuf_bptr_ref_t', is a `reference pointer' to `mbuf_bptr_t`, and
+ *          is another possible result of creating a `reference pointer' to
+ *          `mbuf_t', following the rule (h) above.
+ *
+ */
+
+/*
+ * Constraint contract constants.
+ *
+ * At the moment only clang (when compiled with `ptrcheck' feature) supports
+ * pointer tagging via `__single', `__indexable' and `__bidi_indexable' attributes.
+ *
+ * During the transitional period, the `__indexable__' and `__bidi_indexable'
+ * constraints will decay to raw pointers if the `ptrcheck' feature is not enabled.
+ * Once the transitional period is over, the `__CCT_CONTRACT_ATTR_{B}PTR' constraints
+ * will stop decaying to raw pointers when built by sufficiently recent version
+ * of clang.
+ *
+ * Support for other compilers will be added after the introduction of support
+ * for pointer tagging on those compilers.
+ */
+#if defined(__clang__)
+#define __CCT_CONTRACT_ATTR_REF         __single
+#define __CCT_CONTRACT_ATTR_CREF        const __single
+#if  __has_ptrcheck
+#define __CCT_CONTRACT_ATTR_BPTR        __bidi_indexable
+#define __CCT_CONTRACT_ATTR_PTR         __indexable
+#else /* __clang__ + __has_ptrcheck */
+#define __CCT_CONTRACT_ATTR_BPTR
+#define __CCT_CONTRACT_ATTR_PTR
+#endif /* __clang__ + !__has_ptrcheck */
+#else /* !__clang__ */
+#define __CCT_CONTRACT_ATTR_REF
+#define __CCT_CONTRACT_ATTR_CREF        const
+#define __CCT_CONTRACT_ATTR_BPTR
+#define __CCT_CONTRACT_ATTR_PTR
+#endif /* __clang__ */
+
+#define __CCT_CONTRACT_TAG_REF          _ref
+#define __CCT_CONTRACT_TAG_CREF         _cref
+#define __CCT_CONTRACT_TAG_BPTR         _bptr
+#define __CCT_CONTRACT_TAG_PTR          _ptr
+
+/* Helper macros */
+#define __CCT_DEFER(F, ...) F(__VA_ARGS__)
+#define __CCT_CONTRACT_TO_ATTR(kind) __CONCAT(__CCT_CONTRACT_ATTR_, kind)
+#define __CCT_CONTRACT_TO_TAG(kind)  __CCT_DEFER(__CONCAT, __CCT_CONTRACT_TAG_, kind)
+
+#define __CCT_COUNT_ARGS1(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, N, ...) N
+#define __CCT_COUNT_ARGS(...) \
+	__CCT_COUNT_ARGS1(, __VA_ARGS__, _9, _8, _7, _6, _5, _4, _3, _2, _1, _0)
+#define __CCT_DISPATCH1(base, N, ...) __CONCAT(base, N)(__VA_ARGS__)
+#define __CCT_DISPATCH(base, ...) \
+	__CCT_DISPATCH1(base, __CCT_COUNT_ARGS(__VA_ARGS__), __VA_ARGS__)
+
+/* Covert a contract list to a type suffix */
+#define __CCT_CONTRACT_LIST_TO_TAGGED_SUFFIX_1(kind)                                                \
+	__CCT_DEFER(__CONCAT, __CCT_CONTRACT_TO_TAG(kind), _t)
+#define __CCT_CONTRACT_LIST_TO_TAGGED_SUFFIX_2(kind1, kind2)                                        \
+	__CCT_DEFER(__CONCAT, __CCT_CONTRACT_TO_TAG(kind1),                                             \
+	         __CCT_CONTRACT_LIST_TO_TAGGED_SUFFIX_1(kind2))
+#define __CCT_CONTRACT_LIST_TO_TAGGED_SUFFIX_3(kind1, kind2, kind3)                                 \
+	__CCT_DEFER(__CONCAT, __CCT_CONTRACT_TO_TAG(kind1),                                             \
+	         __CCT_CONTRACT_LIST_TO_TAGGED_SUFFIX_2(kind2, kind3))
+
+/* Create typedefs for the constrained pointer type */
+#define __CCT_DECLARE_CONSTRAINED_PTR_TYPE_3(basetype, basetag, kind)                               \
+typedef basetype * __CCT_CONTRACT_TO_ATTR(kind)                                                     \
+	__CCT_DEFER(__CONCAT, basetag,  __CCT_CONTRACT_LIST_TO_TAGGED_SUFFIX_1(kind))
+
+#define __CCT_DECLARE_CONSTRAINED_PTR_TYPE_4(basetype, basetag, kind1, kind2)                       \
+typedef basetype * __CCT_CONTRACT_TO_ATTR(kind1)                                                    \
+	         * __CCT_CONTRACT_TO_ATTR(kind2)                                                        \
+	__CCT_DEFER(__CONCAT, basetag,  __CCT_CONTRACT_LIST_TO_TAGGED_SUFFIX_2(kind1, kind2))
+
+#define __CCT_DECLARE_CONSTRAINED_PTR_TYPE_5(basetype, basetag, kind1, kind2, kind3)                \
+typedef basetype * __CCT_CONTRACT_TO_ATTR(kind1)                                                    \
+	         * __CCT_CONTRACT_TO_ATTR(kind2)                                                        \
+	         * __CCT_CONTRACT_TO_ATTR(kind3)                                                        \
+	__CCT_DEFER(__CONCAT, basetag,  __CCT_CONTRACT_LIST_TO_TAGGED_SUFFIX_3(kind1, kind2, kind3))
+
+/*
+ * Lower level type constructor.
+ */
+#define __CCT_DECLARE_CONSTRAINED_PTR_TYPE(basetype, basetag, ...)                                  \
+	__CCT_DISPATCH(__CCT_DECLARE_CONSTRAINED_PTR_TYPE, basetype, basetag, __VA_ARGS__)
+
+/*
+ * Higher level type constructors.
+ * The constrained types that can potentially break the ABI are not exposed
+ * into the user-space.
+ */
+#define __CCT_DECLARE_CONSTRAINED_PTR_TYPES(basetype, basetag)                                      \
+__CCT_DECLARE_CONSTRAINED_PTR_TYPE(basetype, basetag, REF);                                         \
+__CCT_DECLARE_CONSTRAINED_PTR_TYPE(basetype, basetag, REF, REF)
+
+#endif /* __CONSTRAINED_CTYPES__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/event.h b/lib/libc/include/any-macos.13-any/sys/event.h
similarity index 98%
rename from lib/libc/include/x86_64-macos.10-none/sys/event.h
rename to lib/libc/include/any-macos.13-any/sys/event.h
index 1fbce9a75c..d56e6dfaf0 100644
--- a/lib/libc/include/x86_64-macos.10-none/sys/event.h
+++ b/lib/libc/include/any-macos.13-any/sys/event.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003-2019 Apple Inc. All rights reserved.
+ * Copyright (c) 2003-2021 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -58,7 +58,9 @@
 
 #include <machine/types.h>
 #include <sys/cdefs.h>
+#include <sys/queue.h>
 #include <stdint.h>
+#include <sys/types.h>
 
 /*
  * Filter types
@@ -242,6 +244,8 @@ struct kevent64_s {
 #define NOTE_REVOKE     0x00000040              /* vnode access was revoked */
 #define NOTE_NONE       0x00000080              /* No specific vnode event: to test for EVFILT_READ activation*/
 #define NOTE_FUNLOCK    0x00000100              /* vnode was unlocked by flock(2) */
+#define NOTE_LEASE_DOWNGRADE 0x00000200         /* lease downgrade requested */
+#define NOTE_LEASE_RELEASE 0x00000400           /* lease release requested */
 
 /*
  * data/hint fflags for EVFILT_PROC, shared with userspace
@@ -262,7 +266,7 @@ enum {
 #define NOTE_EXEC               0x20000000      /* process exec'd */
 #define NOTE_REAP               ((unsigned int)eNoteReapDeprecated /* 0x10000000 */ )   /* process reaped */
 #define NOTE_SIGNAL             0x08000000      /* shared with EVFILT_SIGNAL */
-#define NOTE_EXITSTATUS         0x04000000      /* exit status to be returned, valid for child process only */
+#define NOTE_EXITSTATUS         0x04000000      /* exit status to be returned, valid for child process or when allowed to signal target pid */
 #define NOTE_EXIT_DETAIL        0x02000000      /* provide details on reasons for exit */
 
 #define NOTE_PDATAMASK  0x000fffff              /* mask for signal & exit status */
@@ -366,13 +370,10 @@ enum {
 
 
 /* Temporay solution for BootX to use inode.h till kqueue moves to vfs layer */
-#include <sys/queue.h>
 struct knote;
 SLIST_HEAD(klist, knote);
 
 
-#include <sys/types.h>
-
 struct timespec;
 
 __BEGIN_DECLS
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/fcntl.h b/lib/libc/include/any-macos.13-any/sys/fcntl.h
similarity index 81%
rename from lib/libc/include/x86_64-macos.10-none/sys/fcntl.h
rename to lib/libc/include/any-macos.13-any/sys/fcntl.h
index 9326ed0dab..5f7d0d6524 100644
--- a/lib/libc/include/x86_64-macos.10-none/sys/fcntl.h
+++ b/lib/libc/include/any-macos.13-any/sys/fcntl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2013 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2022 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -107,24 +107,60 @@
  * which was documented to use FREAD/FWRITE, continues to work.
  */
 #if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define FREAD           0x0001
-#define FWRITE          0x0002
+#define FREAD           0x00000001
+#define FWRITE          0x00000002
 #endif
-#define O_NONBLOCK      0x0004          /* no delay */
-#define O_APPEND        0x0008          /* set append mode */
+#define O_NONBLOCK      0x00000004      /* no delay */
+#define O_APPEND        0x00000008      /* set append mode */
 
 #include <sys/_types/_o_sync.h>
 
 #if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define O_SHLOCK        0x0010          /* open with shared file lock */
-#define O_EXLOCK        0x0020          /* open with exclusive file lock */
-#define O_ASYNC         0x0040          /* signal pgrp when data ready */
+#define O_SHLOCK        0x00000010      /* open with shared file lock */
+#define O_EXLOCK        0x00000020      /* open with exclusive file lock */
+#define O_ASYNC         0x00000040      /* signal pgrp when data ready */
 #define O_FSYNC         O_SYNC          /* source compatibility: do not use */
-#define O_NOFOLLOW  0x0100      /* don't follow symlinks */
+#define O_NOFOLLOW      0x00000100      /* don't follow symlinks */
 #endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-#define O_CREAT         0x0200          /* create if nonexistant */
-#define O_TRUNC         0x0400          /* truncate to zero length */
-#define O_EXCL          0x0800          /* error if already exists */
+#define O_CREAT         0x00000200      /* create if nonexistant */
+#define O_TRUNC         0x00000400      /* truncate to zero length */
+#define O_EXCL          0x00000800      /* error if already exists */
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+#define O_EVTONLY       0x00008000      /* descriptor requested for event notifications only */
+#endif
+
+
+#define O_NOCTTY        0x00020000      /* don't assign controlling terminal */
+
+
+#if __DARWIN_C_LEVEL >= 200809L
+#define O_DIRECTORY     0x00100000
+#endif
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+#define O_SYMLINK       0x00200000      /* allow open of a symlink */
+#endif
+
+//      O_DSYNC         0x00400000      /* synch I/O data integrity */
+#include <sys/_types/_o_dsync.h>
+
+
+#if __DARWIN_C_LEVEL >= 200809L
+#define O_CLOEXEC       0x01000000      /* implicitly set FD_CLOEXEC */
+#endif
+
+
+#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
+#define O_NOFOLLOW_ANY  0x20000000      /* no symlinks allowed in path */
+#endif
+
+#if __DARWIN_C_LEVEL >= 200809L
+#define O_EXEC          0x40000000               /* open file for execute only */
+#define O_SEARCH        (O_EXEC | O_DIRECTORY)   /* open directory for search only */
+#endif
+
+
 
 #if __DARWIN_C_LEVEL >= 200809L
 /*
@@ -142,37 +178,18 @@
 #if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
 #define AT_REALDEV              0x0200  /* Return real device inodes resides on for fstatat(2) */
 #define AT_FDONLY               0x0400  /* Use only the fd and Ignore the path for fstatat(2) */
+#define AT_SYMLINK_NOFOLLOW_ANY 0x0800  /* Path should not contain any symlinks */
 #endif
 #endif
 
 #if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define O_EVTONLY       0x8000          /* descriptor requested for event notifications only */
-#endif
-
-
-#define O_NOCTTY        0x20000         /* don't assign controlling terminal */
-
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define O_DIRECTORY     0x100000
-#define O_SYMLINK       0x200000        /* allow open of a symlink */
-#endif
-
-#include <sys/_types/_o_dsync.h>
-
-
-#if __DARWIN_C_LEVEL >= 200809L
-#define O_CLOEXEC       0x1000000       /* implicitly set FD_CLOEXEC */
-#endif
-
-
-
-
-
 /* Data Protection Flags */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
 #define O_DP_GETRAWENCRYPTED    0x0001
 #define O_DP_GETRAWUNENCRYPTED  0x0002
+#define O_DP_AUTHENTICATE       0x0004
+
+/* Descriptor value for openat_authenticated_np() to skip authentication with another fd */
+#define AUTH_OPEN_NOAUTHFD      -1
 #endif
 
 
@@ -224,7 +241,7 @@
 #define F_FLUSH_DATA    40
 #define F_CHKCLEAN      41              /* Used for regression test */
 #define F_PREALLOCATE   42              /* Preallocate storage */
-#define F_SETSIZE       43              /* Truncate a file without zeroing space */
+#define F_SETSIZE       43              /* Truncate a file. Equivalent to calling truncate(2) */
 #define F_RDADVISE      44              /* Issue an advisory read async with no copy to user */
 #define F_RDAHEAD       45              /* turn read ahead off/on for this fd */
 /*
@@ -253,7 +270,13 @@
 
 #define F_LOG2PHYS_EXT  65              /* file offset to device offset, extended */
 
-#define F_GETLKPID              66              /* get record locking information, per-process */
+#define F_GETLKPID              66      /* See man fcntl(2) F_GETLK
+	                                 * Similar to F_GETLK but in addition l_pid is treated as an input parameter
+	                                 * which is used as a matching value when searching locks on the file
+	                                 * so that only locks owned by the process with pid l_pid are returned.
+	                                 * However, any flock(2) type lock will also be found with the returned value
+	                                 * of l_pid set to -1 (as with F_GETLK).
+	                                 */
 
 /* See F_DUPFD_CLOEXEC below for 67 */
 
@@ -293,6 +316,18 @@
 
 #define F_GETPATH_NOFIRMLINK       102              /* return the full path without firmlinks of the fd */
 
+#define F_ADDFILESIGS_INFO      103     /* Add signature from same file, return information */
+#define F_ADDFILESUPPL          104     /* Add supplemental signature from same file with fd reference to original */
+#define F_GETSIGSINFO           105     /* Look up code signature information attached to a file or slice */
+
+#define F_SETLEASE              106      /* Acquire or release lease */
+#define F_GETLEASE              107      /* Retrieve lease information */
+
+#define F_SETLEASE_ARG(t, oc)   ((t) | ((oc) << 2))
+
+
+#define F_TRANSFEREXTENTS       110      /* Transfer allocated extents beyond leof to a different file */
+
 // FS-specific fcntl()'s numbers begin at 0x00010000 and go up
 #define FCNTL_FS_SPECIFIC_BASE  0x00010000
 
@@ -328,6 +363,7 @@
 
 #define F_ALLOCATECONTIG  0x00000002    /* allocate contigious space */
 #define F_ALLOCATEALL     0x00000004    /* allocate all requested space or no space at all */
+#define F_ALLOCATEPERSIST 0x00000008    /* do not free space upon close(2) */
 
 /* Position Modes (fst_posmode) for F_PREALLOCATE */
 
@@ -374,30 +410,34 @@ struct radvisory {
 };
 
 
-/** Information the user passes in to get the codeblobs out of the kernel */
-typedef struct fcodeblobs {
-	void            *f_cd_hash;
-	size_t          f_hash_size;
-	void            *f_cd_buffer;
-	size_t          f_cd_size;
-	unsigned int    *f_out_size;
-	int             f_arch;
-	int             __padding;
-} fcodeblobs_t;
-
-
 /*
  * detached code signatures data type -
  * information passed by user to system used by F_ADDSIGS and F_ADDFILESIGS.
  * F_ADDFILESIGS is a shortcut for files that contain their own signature and
  * doesn't require mapping of the file in order to load the signature.
  */
+#define USER_FSIGNATURES_CDHASH_LEN 20
 typedef struct fsignatures {
 	off_t           fs_file_start;
 	void            *fs_blob_start;
 	size_t          fs_blob_size;
+
+	/* The following fields are only applicable to F_ADDFILESIGS_INFO (64bit only). */
+	/* Prior to F_ADDFILESIGS_INFO, this struct ended after fs_blob_size. */
+	size_t          fs_fsignatures_size;// input: size of this struct (for compatibility)
+	char            fs_cdhash[USER_FSIGNATURES_CDHASH_LEN];     // output: cdhash
+	int             fs_hash_type;// output: hash algorithm type for cdhash
 } fsignatures_t;
 
+typedef struct fsupplement {
+	off_t           fs_file_start;   /* offset of Mach-O image in FAT file  */
+	off_t           fs_blob_start;   /* offset of signature in Mach-O image */
+	size_t          fs_blob_size;    /* signature blob size                 */
+	int             fs_orig_fd;      /* address of original image           */
+} fsupplement_t;
+
+
+
 /*
  * DYLD needs to check if the object is allowed to be combined
  * into the main binary. This is done between the code signature
@@ -415,6 +455,19 @@ typedef struct fchecklv {
 } fchecklv_t;
 
 
+/* At this time F_GETSIGSINFO can only indicate platformness.
+ *  As additional requestable information is defined, new keys will be added and the
+ *  fgetsigsinfo_t structure will be lengthened to add space for the additional information
+ */
+#define GETSIGSINFO_PLATFORM_BINARY 1
+
+/* fgetsigsinfo_t used by F_GETSIGSINFO command */
+typedef struct fgetsigsinfo {
+	off_t fg_file_start; /* IN: Offset in the file to look for a signature, -1 for any signature */
+	int   fg_info_request; /* IN: Key indicating the info requested */
+	int   fg_sig_is_platform; /* OUT: 1 if the signature is a plat form binary, 0 if not */
+} fgetsigsinfo_t;
+
 
 /* lock operations for flock(2) */
 #define LOCK_SH         0x01            /* shared file lock */
@@ -454,14 +507,6 @@ typedef struct fspecread {
 	off_t fsr_length;        /* IN: size of the region */
 } fspecread_t;
 
-/* fbootstraptransfer_t used by F_READBOOTSTRAP and F_WRITEBOOTSTRAP commands */
-
-typedef struct fbootstraptransfer {
-	off_t fbt_offset;       /* IN: offset to start read/write */
-	size_t fbt_length;    /* IN: number of bytes to transfer */
-	void *fbt_buffer;       /* IN: buffer to be read/written */
-} fbootstraptransfer_t;
-
 
 /*
  * For F_LOG2PHYS this information is passed back to user
@@ -541,6 +586,8 @@ int     openx_np(const char *, int, filesec_t);
  *  int open_dprotected_np(user_addr_t path, int flags, int class, int dpflags, int mode)
  */
 int open_dprotected_np( const char *, int, int, int, ...);
+int openat_dprotected_np( int, const char *, int, int, int, ...);
+int openat_authenticated_np(int, const char *, int, int);
 int     flock(int, int);
 filesec_t filesec_init(void);
 filesec_t filesec_dup(filesec_t);
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/ioctl.h b/lib/libc/include/any-macos.13-any/sys/filio.h
similarity index 78%
rename from lib/libc/include/x86_64-macos.10-none/sys/ioctl.h
rename to lib/libc/include/any-macos.13-any/sys/filio.h
index bb84842dd2..5744524f5b 100644
--- a/lib/libc/include/x86_64-macos.10-none/sys/ioctl.h
+++ b/lib/libc/include/any-macos.13-any/sys/filio.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2022 Apple Computer, Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -63,48 +63,23 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- *	@(#)ioctl.h	8.6 (Berkeley) 3/28/94
+ *	@(#)filio.h	8.1 (Berkeley) 3/28/94
  */
 
-#ifndef _SYS_IOCTL_H_
-#define _SYS_IOCTL_H_
-
-#include <sys/ttycom.h>
-
-/*
- * Pun for SunOS prior to 3.2.  SunOS 3.2 and later support TIOCGWINSZ
- * and TIOCSWINSZ (yes, even 3.2-3.5, the fact that it wasn't documented
- * nonwithstanding).
- */
-struct ttysize {
-	unsigned short  ts_lines;
-	unsigned short  ts_cols;
-	unsigned short  ts_xxx;
-	unsigned short  ts_yyy;
-};
-#define TIOCGSIZE       TIOCGWINSZ
-#define TIOCSSIZE       TIOCSWINSZ
+#ifndef _SYS_FILIO_H_
+#define _SYS_FILIO_H_
 
 #include <sys/ioccom.h>
 
-#include <sys/filio.h>
-#include <sys/sockio.h>
+/* Generic file-descriptor ioctl's. */
+#define FIOCLEX          _IO('f', 1)            /* set close on exec on fd */
+#define FIONCLEX         _IO('f', 2)            /* remove close on exec */
+#define FIONREAD        _IOR('f', 127, int)     /* get # bytes to read */
+#define FIONBIO         _IOW('f', 126, int)     /* set/clear non-blocking i/o */
+#define FIOASYNC        _IOW('f', 125, int)     /* set/clear async i/o */
+#define FIOSETOWN       _IOW('f', 124, int)     /* set owner */
+#define FIOGETOWN       _IOR('f', 123, int)     /* get owner */
+#define FIODTYPE        _IOR('f', 122, int)     /* get d_type */
 
 
-#include <sys/cdefs.h>
-
-__BEGIN_DECLS
-int     ioctl(int, unsigned long, ...);
-__END_DECLS
-#endif /* !_SYS_IOCTL_H_ */
-
-/*
- * Keep outside _SYS_IOCTL_H_
- * Compatability with old terminal driver
- *
- * Source level -> #define USE_OLD_TTY
- * Kernel level -> always on
- */
-#if defined(USE_OLD_TTY) || defined(BSD_KERNEL_PRIVATE)
-#include <sys/ioctl_compat.h>
-#endif /* !_SYS_IOCTL_H_ */
\ No newline at end of file
+#endif /* !_SYS_FILIO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/mount.h b/lib/libc/include/any-macos.13-any/sys/mount.h
similarity index 95%
rename from lib/libc/include/x86_64-macos.10-none/sys/mount.h
rename to lib/libc/include/any-macos.13-any/sys/mount.h
index 0a77b455a6..21b9bf3c12 100644
--- a/lib/libc/include/x86_64-macos.10-none/sys/mount.h
+++ b/lib/libc/include/any-macos.13-any/sys/mount.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2018 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2021 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -82,6 +82,7 @@
 #include <Availability.h>
 
 #include <sys/_types/_fsid_t.h> /* file system id type */
+#include <sys/_types/_graftdmg_un.h>
 
 /*
  * file system statistics
@@ -228,6 +229,7 @@ struct vfsstatfs {
 #define MNT_NOUSERXATTR 0x01000000      /* Don't allow user extended attributes */
 #define MNT_DEFWRITE    0x02000000      /* filesystem should defer writes */
 #define MNT_MULTILABEL  0x04000000      /* MAC support for individual labels */
+#define MNT_NOFOLLOW    0x08000000      /* don't follow symlink when resolving mount point */
 #define MNT_NOATIME             0x10000000      /* disable update of file access time */
 #define MNT_SNAPSHOT    0x40000000 /* The mount is a snapshot */
 #define MNT_STRICTATIME 0x80000000      /* enable strict update of file access time */
@@ -247,7 +249,8 @@ struct vfsstatfs {
 	                MNT_ROOTFS	| MNT_DOVOLFS	| MNT_DONTBROWSE | \
 	                MNT_IGNORE_OWNERSHIP | MNT_AUTOMOUNTED | MNT_JOURNALED | \
 	                MNT_NOUSERXATTR | MNT_DEFWRITE	| MNT_MULTILABEL | \
-	                MNT_NOATIME | MNT_STRICTATIME | MNT_SNAPSHOT | MNT_CPROTECT)
+	                MNT_NOFOLLOW | MNT_NOATIME | MNT_STRICTATIME | \
+	                MNT_SNAPSHOT | MNT_CPROTECT)
 /*
  * External filesystem command modifier flags.
  * Unmount can use the MNT_FORCE flag.
@@ -324,7 +327,7 @@ struct vfsidctl {
  * New style VFS sysctls, do not reuse/conflict with the namespace for
  * private sysctls.
  */
-#define VFS_CTL_STATFS  0x00010001      /* statfs */
+#define VFS_CTL_OSTATFS 0x00010001      /* old legacy statfs */
 #define VFS_CTL_UMOUNT  0x00010002      /* unmount */
 #define VFS_CTL_QUERY   0x00010003      /* anything wrong? (vfsquery) */
 #define VFS_CTL_NEWADDR 0x00010004      /* reconnect to new address */
@@ -334,6 +337,17 @@ struct vfsidctl {
 #define VFS_CTL_DISC    0x00010008      /* server disconnected */
 #define VFS_CTL_SERVERINFO  0x00010009  /* information about fs server */
 #define VFS_CTL_NSTATUS 0x0001000A      /* netfs mount status */
+#define VFS_CTL_STATFS64 0x0001000B     /* statfs64 */
+
+/*
+ * Automatically select the correct VFS_CTL_*STATFS* flavor based
+ * on what "struct statfs" layout the client will use.
+ */
+#if __DARWIN_64_BIT_INO_T
+#define VFS_CTL_STATFS  VFS_CTL_STATFS64
+#else
+#define VFS_CTL_STATFS  VFS_CTL_OSTATFS
+#endif
 
 struct vfsquery {
 	u_int32_t       vq_flags;
@@ -377,7 +391,6 @@ struct netfs_status {
 
 
 
-
 /*
  * Generic file handle
  */
@@ -391,6 +404,13 @@ struct fhandle {
 };
 typedef struct fhandle  fhandle_t;
 
+OS_ENUM(graftdmg_type, uint32_t,
+    GRAFTDMG_CRYPTEX_BOOT = 1,
+    GRAFTDMG_CRYPTEX_PREBOOT = 2,
+    GRAFTDMG_CRYPTEX_DOWNLEVEL = 3);
+
+
+
 
 __BEGIN_DECLS
 int     fhopen(const struct fhandle *, int);
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/proc_info.h b/lib/libc/include/any-macos.13-any/sys/proc_info.h
similarity index 94%
rename from lib/libc/include/x86_64-macos.10-none/sys/proc_info.h
rename to lib/libc/include/any-macos.13-any/sys/proc_info.h
index 90850710b9..e59e5256b7 100644
--- a/lib/libc/include/x86_64-macos.10-none/sys/proc_info.h
+++ b/lib/libc/include/any-macos.13-any/sys/proc_info.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005-2017 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2005-2021 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -100,8 +100,6 @@ struct proc_bsdshortinfo {
 };
 
 
-
-
 /* pbi_flags values */
 #define PROC_FLAG_SYSTEM        1       /*  System process */
 #define PROC_FLAG_TRACED        2       /* process currently being traced, possibly by gdb */
@@ -472,6 +470,17 @@ struct kern_ctl_info {
 	char            kcsi_name[MAX_KCTL_NAME];       /* unique nke identifier, provided by DTS */
 };
 
+/*
+ * VSock Sockets
+ */
+
+struct vsock_sockinfo {
+	uint32_t        local_cid;
+	uint32_t        local_port;
+	uint32_t        remote_cid;
+	uint32_t        remote_port;
+};
+
 /* soi_state */
 
 #define SOI_S_NOFDREF           0x0001  /* no file table ref any more */
@@ -506,7 +515,8 @@ enum {
 	SOCKINFO_UN             = 3,
 	SOCKINFO_NDRV           = 4,
 	SOCKINFO_KERN_EVENT     = 5,
-	SOCKINFO_KERN_CTL       = 6
+	SOCKINFO_KERN_CTL       = 6,
+	SOCKINFO_VSOCK          = 7,
 };
 
 struct socket_info {
@@ -536,6 +546,7 @@ struct socket_info {
 		struct ndrv_info        pri_ndrv;               /* SOCKINFO_NDRV */
 		struct kern_event_info  pri_kern_event;         /* SOCKINFO_KERN_EVENT */
 		struct kern_ctl_info    pri_kern_ctl;           /* SOCKINFO_KERN_CTL */
+		struct vsock_sockinfo   pri_vsock;              /* SOCKINFO_VSOCK */
 	}                                       soi_proto;
 };
 
@@ -607,12 +618,11 @@ struct kqueue_dyninfo {
 };
 
 /* keep in sync with KQ_* in sys/eventvar.h */
-#define PROC_KQUEUE_SELECT      0x01
-#define PROC_KQUEUE_SLEEP       0x02
-#define PROC_KQUEUE_32          0x08
-#define PROC_KQUEUE_64          0x10
-#define PROC_KQUEUE_QOS         0x20
-
+#define PROC_KQUEUE_SELECT      0x0001
+#define PROC_KQUEUE_SLEEP       0x0002
+#define PROC_KQUEUE_32          0x0008
+#define PROC_KQUEUE_64          0x0010
+#define PROC_KQUEUE_QOS         0x0020
 
 struct kqueue_fdinfo {
 	struct proc_fileinfo    pfi;
@@ -640,6 +650,8 @@ typedef uint64_t proc_info_udata_t;
 #define PROX_FDTYPE_PIPE        6
 #define PROX_FDTYPE_FSEVENTS    7
 #define PROX_FDTYPE_NETPOLICY   9
+#define PROX_FDTYPE_CHANNEL     10
+#define PROX_FDTYPE_NEXUS       11
 
 struct proc_fdinfo {
 	int32_t                 proc_fd;
@@ -651,6 +663,39 @@ struct proc_fileportinfo {
 	uint32_t                proc_fdtype;
 };
 
+/*
+ * Channel
+ */
+
+/* type */
+#define PROC_CHANNEL_TYPE_USER_PIPE             0
+#define PROC_CHANNEL_TYPE_KERNEL_PIPE           1
+#define PROC_CHANNEL_TYPE_NET_IF                2
+#define PROC_CHANNEL_TYPE_FLOW_SWITCH           3
+
+/* flags */
+#define PROC_CHANNEL_FLAGS_MONITOR_TX           0x1
+#define PROC_CHANNEL_FLAGS_MONITOR_RX           0x2
+#define PROC_CHANNEL_FLAGS_MONITOR_NO_COPY      0x4
+#define PROC_CHANNEL_FLAGS_EXCLUSIVE            0x10
+#define PROC_CHANNEL_FLAGS_USER_PACKET_POOL     0x20
+#define PROC_CHANNEL_FLAGS_DEFUNCT_OK           0x40
+#define PROC_CHANNEL_FLAGS_LOW_LATENCY          0x80
+#define PROC_CHANNEL_FLAGS_MONITOR                                      \
+	(PROC_CHANNEL_FLAGS_MONITOR_TX | PROC_CHANNEL_FLAGS_MONITOR_RX)
+
+struct proc_channel_info {
+	uuid_t                  chi_instance;
+	uint32_t                chi_port;
+	uint32_t                chi_type;
+	uint32_t                chi_flags;
+	uint32_t                rfu_1;/* reserved */
+};
+
+struct channel_fdinfo {
+	struct proc_fileinfo    pfi;
+	struct proc_channel_info channelinfo;
+};
 
 /* Flavors for proc_pidinfo() */
 #define PROC_PIDLISTFDS                 1
@@ -729,6 +774,8 @@ struct proc_fileportinfo {
 #define PROC_PIDFDATALKINFO_SIZE        (sizeof(struct appletalk_fdinfo))
 
 
+#define PROC_PIDFDCHANNELINFO           10
+#define PROC_PIDFDCHANNELINFO_SIZE      (sizeof(struct channel_fdinfo))
 
 /* Flavors for proc_pidfileportinfo */
 
@@ -780,6 +827,7 @@ struct proc_fileportinfo {
 
 
 
+
 __END_DECLS
 
 #endif /*_SYS_PROC_INFO_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/resource.h b/lib/libc/include/any-macos.13-any/sys/resource.h
similarity index 81%
rename from lib/libc/include/x86_64-macos.10-none/sys/resource.h
rename to lib/libc/include/any-macos.13-any/sys/resource.h
index b6bf678d37..4e1c86636c 100644
--- a/lib/libc/include/x86_64-macos.10-none/sys/resource.h
+++ b/lib/libc/include/any-macos.13-any/sys/resource.h
@@ -188,7 +188,14 @@ struct  rusage {
 #define RUSAGE_INFO_V2  2
 #define RUSAGE_INFO_V3  3
 #define RUSAGE_INFO_V4  4
-#define RUSAGE_INFO_CURRENT     RUSAGE_INFO_V4
+#define RUSAGE_INFO_V5  5
+#define RUSAGE_INFO_V6  6
+#define RUSAGE_INFO_CURRENT RUSAGE_INFO_V6
+
+/*
+ * Flags for RUSAGE_INFO_V5
+ */
+#define RU_PROC_RUNS_RESLIDE    0x00000001      /* proc has reslid shared cache */
 
 typedef void *rusage_info_t;
 
@@ -318,7 +325,94 @@ struct rusage_info_v4 {
 	uint64_t ri_runnable_time;
 };
 
-typedef struct rusage_info_v4 rusage_info_current;
+struct rusage_info_v5 {
+	uint8_t  ri_uuid[16];
+	uint64_t ri_user_time;
+	uint64_t ri_system_time;
+	uint64_t ri_pkg_idle_wkups;
+	uint64_t ri_interrupt_wkups;
+	uint64_t ri_pageins;
+	uint64_t ri_wired_size;
+	uint64_t ri_resident_size;
+	uint64_t ri_phys_footprint;
+	uint64_t ri_proc_start_abstime;
+	uint64_t ri_proc_exit_abstime;
+	uint64_t ri_child_user_time;
+	uint64_t ri_child_system_time;
+	uint64_t ri_child_pkg_idle_wkups;
+	uint64_t ri_child_interrupt_wkups;
+	uint64_t ri_child_pageins;
+	uint64_t ri_child_elapsed_abstime;
+	uint64_t ri_diskio_bytesread;
+	uint64_t ri_diskio_byteswritten;
+	uint64_t ri_cpu_time_qos_default;
+	uint64_t ri_cpu_time_qos_maintenance;
+	uint64_t ri_cpu_time_qos_background;
+	uint64_t ri_cpu_time_qos_utility;
+	uint64_t ri_cpu_time_qos_legacy;
+	uint64_t ri_cpu_time_qos_user_initiated;
+	uint64_t ri_cpu_time_qos_user_interactive;
+	uint64_t ri_billed_system_time;
+	uint64_t ri_serviced_system_time;
+	uint64_t ri_logical_writes;
+	uint64_t ri_lifetime_max_phys_footprint;
+	uint64_t ri_instructions;
+	uint64_t ri_cycles;
+	uint64_t ri_billed_energy;
+	uint64_t ri_serviced_energy;
+	uint64_t ri_interval_max_phys_footprint;
+	uint64_t ri_runnable_time;
+	uint64_t ri_flags;
+};
+
+struct rusage_info_v6 {
+	uint8_t  ri_uuid[16];
+	uint64_t ri_user_time;
+	uint64_t ri_system_time;
+	uint64_t ri_pkg_idle_wkups;
+	uint64_t ri_interrupt_wkups;
+	uint64_t ri_pageins;
+	uint64_t ri_wired_size;
+	uint64_t ri_resident_size;
+	uint64_t ri_phys_footprint;
+	uint64_t ri_proc_start_abstime;
+	uint64_t ri_proc_exit_abstime;
+	uint64_t ri_child_user_time;
+	uint64_t ri_child_system_time;
+	uint64_t ri_child_pkg_idle_wkups;
+	uint64_t ri_child_interrupt_wkups;
+	uint64_t ri_child_pageins;
+	uint64_t ri_child_elapsed_abstime;
+	uint64_t ri_diskio_bytesread;
+	uint64_t ri_diskio_byteswritten;
+	uint64_t ri_cpu_time_qos_default;
+	uint64_t ri_cpu_time_qos_maintenance;
+	uint64_t ri_cpu_time_qos_background;
+	uint64_t ri_cpu_time_qos_utility;
+	uint64_t ri_cpu_time_qos_legacy;
+	uint64_t ri_cpu_time_qos_user_initiated;
+	uint64_t ri_cpu_time_qos_user_interactive;
+	uint64_t ri_billed_system_time;
+	uint64_t ri_serviced_system_time;
+	uint64_t ri_logical_writes;
+	uint64_t ri_lifetime_max_phys_footprint;
+	uint64_t ri_instructions;
+	uint64_t ri_cycles;
+	uint64_t ri_billed_energy;
+	uint64_t ri_serviced_energy;
+	uint64_t ri_interval_max_phys_footprint;
+	uint64_t ri_runnable_time;
+	uint64_t ri_flags;
+	uint64_t ri_user_ptime;
+	uint64_t ri_system_ptime;
+	uint64_t ri_pinstructions;
+	uint64_t ri_pcycles;
+	uint64_t ri_energy_nj;
+	uint64_t ri_penergy_nj;
+	uint64_t ri_reserved[14];
+};
+
+typedef struct rusage_info_v6 rusage_info_current;
 
 #endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
 
@@ -409,6 +503,12 @@ struct proc_rlimit_control_wakeupmon {
 #define IOPOL_TYPE_VFS_ATIME_UPDATES 2
 #define IOPOL_TYPE_VFS_MATERIALIZE_DATALESS_FILES 3
 #define IOPOL_TYPE_VFS_STATFS_NO_DATA_VOLUME 4
+#define IOPOL_TYPE_VFS_TRIGGER_RESOLVE 5
+#define IOPOL_TYPE_VFS_IGNORE_CONTENT_PROTECTION 6
+#define IOPOL_TYPE_VFS_IGNORE_PERMISSIONS 7
+#define IOPOL_TYPE_VFS_SKIP_MTIME_UPDATE 8
+#define IOPOL_TYPE_VFS_ALLOW_LOW_SPACE_WRITES 9
+#define IOPOL_TYPE_VFS_DISALLOW_RW_FOR_O_EVTONLY 10
 
 /* scope */
 #define IOPOL_SCOPE_PROCESS   0
@@ -438,6 +538,24 @@ struct proc_rlimit_control_wakeupmon {
 #define IOPOL_VFS_STATFS_NO_DATA_VOLUME_DEFAULT 0
 #define IOPOL_VFS_STATFS_FORCE_NO_DATA_VOLUME   1
 
+#define IOPOL_VFS_TRIGGER_RESOLVE_DEFAULT 0
+#define IOPOL_VFS_TRIGGER_RESOLVE_OFF     1
+
+#define IOPOL_VFS_CONTENT_PROTECTION_DEFAULT 0
+#define IOPOL_VFS_CONTENT_PROTECTION_IGNORE  1
+
+#define IOPOL_VFS_IGNORE_PERMISSIONS_OFF 0
+#define IOPOL_VFS_IGNORE_PERMISSIONS_ON  1
+
+#define IOPOL_VFS_SKIP_MTIME_UPDATE_OFF 0
+#define IOPOL_VFS_SKIP_MTIME_UPDATE_ON 1
+
+#define IOPOL_VFS_ALLOW_LOW_SPACE_WRITES_OFF 0
+#define IOPOL_VFS_ALLOW_LOW_SPACE_WRITES_ON 1
+
+#define IOPOL_VFS_DISALLOW_RW_FOR_O_EVTONLY_DEFAULT 0
+#define IOPOL_VFS_DISALLOW_RW_FOR_O_EVTONLY_ON 1
+
 #endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
 
 
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/socket.h b/lib/libc/include/any-macos.13-any/sys/socket.h
similarity index 95%
rename from lib/libc/include/x86_64-macos.10-none/sys/socket.h
rename to lib/libc/include/any-macos.13-any/sys/socket.h
index c8a0d27615..4c5a523336 100644
--- a/lib/libc/include/x86_64-macos.10-none/sys/socket.h
+++ b/lib/libc/include/any-macos.13-any/sys/socket.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2022 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -74,10 +74,12 @@
 
 #include <sys/types.h>
 #include <sys/cdefs.h>
+#include <sys/constrained_ctypes.h>
 #include <machine/_param.h>
 #include <net/net_kev.h>
 
 
+
 #include <Availability.h>
 
 /*
@@ -128,6 +130,7 @@
 #if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
 #define SO_USELOOPBACK  0x0040          /* bypass hardware when possible */
 #define SO_LINGER       0x0080          /* linger on close if data present (in ticks) */
+#define SO_LINGER_SEC   0x1080          /* linger on close if data present (in seconds) */
 #else
 #define SO_LINGER       0x1080          /* linger on close if data present (in seconds) */
 #endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
@@ -160,8 +163,8 @@
 #define SO_ERROR        0x1007          /* get error status and clear */
 #define SO_TYPE         0x1008          /* get socket type */
 #if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define SO_LABEL        0x1010          /* socket's MAC label */
-#define SO_PEERLABEL    0x1011          /* socket's peer MAC label */
+#define SO_LABEL        0x1010          /* deprecated */
+#define SO_PEERLABEL    0x1011          /* deprecated */
 #ifdef __APPLE__
 #define SO_NREAD        0x1020          /* APPLE: get 1st-packet byte count */
 #define SO_NKE          0x1021          /* APPLE: Install socket-level NKE */
@@ -173,7 +176,6 @@
 #define SO_NOTIFYCONFLICT       0x1026  /* APPLE: send notification if there is a bind on a port which is already in use */
 #define SO_UPCALLCLOSEWAIT      0x1027  /* APPLE: block on close until an upcall returns */
 #endif
-#define SO_LINGER_SEC   0x1080          /* linger on close if data present (in seconds) */
 #define SO_RANDOMPORT   0x1082  /* APPLE: request local port randomization */
 #define SO_NP_EXTENSIONS        0x1083  /* To turn off some POSIX behavior */
 #endif
@@ -182,7 +184,13 @@
 #define SO_NET_SERVICE_TYPE     0x1116  /* Network service type */
 
 
-#define SO_NETSVC_MARKING_LEVEL 0x1119  /* Get QoS marking in effect for socket */
+#define SO_NETSVC_MARKING_LEVEL    0x1119  /* Get QoS marking in effect for socket */
+
+
+#define SO_RESOLVER_SIGNATURE      0x1131  /* A signed data blob from the system resolver */
+
+
+/* When adding new socket-options, you need to make sure MPTCP supports these as well! */
 
 /*
  * Network Service Type for option SO_NET_SERVICE_TYPE
@@ -398,7 +406,8 @@ struct so_np_extensions {
 #define AF_RESERVED_36  36              /* Reserved for internal usage */
 #define AF_IEEE80211    37              /* IEEE 802.11 protocol */
 #define AF_UTUN         38
-#define AF_MAX          40
+#define AF_VSOCK        40              /* VM Sockets */
+#define AF_MAX          41
 #endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
 
 /*
@@ -407,7 +416,22 @@ struct so_np_extensions {
 struct sockaddr {
 	__uint8_t       sa_len;         /* total length */
 	sa_family_t     sa_family;      /* [XSI] address family */
-	char            sa_data[14];    /* [XSI] addr value (actually larger) */
+#if __has_ptrcheck
+	char            sa_data[__counted_by(sa_len - 2)];
+#else
+	char            sa_data[14];    /* [XSI] addr value (actually smaller or larger) */
+#endif
+};
+__CCT_DECLARE_CONSTRAINED_PTR_TYPES(struct sockaddr, sockaddr);
+
+/*
+ * Least amount of information that a sockaddr requires.
+ * Sockaddr_header is a compatible prefix structure of
+ * all sockaddr objects.
+ */
+struct __sockaddr_header {
+	__uint8_t           sa_len;
+	sa_family_t         sa_family;
 };
 
 #if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
@@ -444,6 +468,7 @@ struct sockaddr_storage {
 	__int64_t       __ss_align;     /* force structure storage alignment */
 	char                    __ss_pad2[_SS_PAD2SIZE];
 };
+__CCT_DECLARE_CONSTRAINED_PTR_TYPES(struct sockaddr_storage, sockaddr_storage);
 
 /*
  * Protocol families, same as address families for now.
@@ -486,6 +511,7 @@ struct sockaddr_storage {
 #define PF_PPP          AF_PPP
 #define PF_RESERVED_36  AF_RESERVED_36
 #define PF_UTUN         AF_UTUN
+#define PF_VSOCK        AF_VSOCK
 #define PF_MAX          AF_MAX
 
 /*
@@ -578,6 +604,13 @@ struct msghdr {
 #define MSG_NEEDSA      0x10000         /* Fail receive if socket address cannot be allocated */
 #endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
 
+#if __DARWIN_C_LEVEL >= 200809L
+#define MSG_NOSIGNAL    0x80000         /* do not generate SIGPIPE on EOF */
+#endif /* __DARWIN_C_LEVEL */
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
+
 /*
  * Header for ancillary data objects in msg_control buffer.
  * Used for additional information with/about a datagram
@@ -671,7 +704,7 @@ struct cmsgcred {
 #define SHUT_WR         1               /* shut down the writing side */
 #define SHUT_RDWR       2               /* shut down both sides */
 
-#if !defined(_POSIX_C_SOURCE)
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
 /*
  * sendfile(2) header/trailer struct
  */
@@ -683,7 +716,7 @@ struct sf_hdtr {
 };
 
 
-#endif  /* !_POSIX_C_SOURCE */
+#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
 
 
 __BEGIN_DECLS
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/spawn.h b/lib/libc/include/any-macos.13-any/sys/spawn.h
similarity index 91%
rename from lib/libc/include/x86_64-macos.10-none/sys/spawn.h
rename to lib/libc/include/any-macos.13-any/sys/spawn.h
index 483f017b69..727b4f5009 100644
--- a/lib/libc/include/x86_64-macos.10-none/sys/spawn.h
+++ b/lib/libc/include/any-macos.13-any/sys/spawn.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2006-2020 Apple Computer, Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -61,6 +61,8 @@
 #define POSIX_SPAWN_SETSID              0x0400
 #define POSIX_SPAWN_CLOEXEC_DEFAULT     0x4000
 
+#define _POSIX_SPAWN_RESLIDE            0x0800
+
 /*
  * Possible values to be set for the process control actions on resource starvation.
  * POSIX_SPAWN_PCONTROL_THROTTLE indicates that the process is to be throttled on starvation.
@@ -72,6 +74,11 @@
 #define POSIX_SPAWN_PCONTROL_SUSPEND    0x0002
 #define POSIX_SPAWN_PCONTROL_KILL       0x0003
 
+#define POSIX_SPAWN_PANIC_ON_CRASH         0x1
+#define POSIX_SPAWN_PANIC_ON_NON_ZERO_EXIT 0x2
+#define POSIX_SPAWN_PANIC_ON_EXIT          0x4
+#define POSIX_SPAWN_PANIC_ON_SPAWN_FAIL    0x8
+
 #endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
 
 #endif  /* _SYS_SPAWN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/stat.h b/lib/libc/include/any-macos.13-any/sys/stat.h
similarity index 98%
rename from lib/libc/include/x86_64-macos.10-none/sys/stat.h
rename to lib/libc/include/any-macos.13-any/sys/stat.h
index 7f2a490ee1..a153272600 100644
--- a/lib/libc/include/x86_64-macos.10-none/sys/stat.h
+++ b/lib/libc/include/any-macos.13-any/sys/stat.h
@@ -361,6 +361,7 @@ struct stat64 __DARWIN_STRUCT_STAT64;
 
 #endif
 
+#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
 /*
  * Extended flags ("EF") returned by ATTR_CMNEXT_EXT_FLAGS from getattrlist/getattrlistbulk
  */
@@ -369,7 +370,8 @@ struct stat64 __DARWIN_STRUCT_STAT64;
 #define EF_IS_SYNC_ROOT         0x00000004      /* file is a sync root for iCloud */
 #define EF_IS_PURGEABLE         0x00000008      /* file is purgeable */
 #define EF_IS_SPARSE            0x00000010      /* file has at least one sparse region */
-
+#define EF_IS_SYNTHETIC         0x00000020      /* a synthetic directory/symlink */
+#endif
 
 
 
@@ -389,6 +391,8 @@ mode_t  umask(mode_t);
 int     fchmodat(int, const char *, mode_t, int) __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
 int     fstatat(int, const char *, struct stat *, int) __DARWIN_INODE64(fstatat) __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
 int     mkdirat(int, const char *, mode_t) __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
+int     mkfifoat(int, const char *, mode_t) __API_AVAILABLE(macos(13.0), ios(16.0), tvos(16.0), watchos(9.0));
+int     mknodat(int, const char *, mode_t, dev_t) __API_AVAILABLE(macos(13.0), ios(16.0), tvos(16.0), watchos(9.0));
 
 #define UTIME_NOW       -1
 #define UTIME_OMIT      -2
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/sysctl.h b/lib/libc/include/any-macos.13-any/sys/sysctl.h
similarity index 89%
rename from lib/libc/include/x86_64-macos.10-none/sys/sysctl.h
rename to lib/libc/include/any-macos.13-any/sys/sysctl.h
index 9e3d84e04c..eebee35881 100644
--- a/lib/libc/include/x86_64-macos.10-none/sys/sysctl.h
+++ b/lib/libc/include/any-macos.13-any/sys/sysctl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2021 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -81,10 +81,10 @@
 #include <sys/appleapiopts.h>
 #include <sys/time.h>
 #include <sys/ucred.h>
+
 #include <sys/proc.h>
 #include <sys/vm.h>
 
-
 /*
  * Definitions for sysctl call.  The sysctl call uses a hierarchical name
  * for objects that can be examined or modified.  The name is expressed as
@@ -135,25 +135,26 @@ struct ctlname {
 	int     ctl_type;       /* type of name */
 };
 
-#define CTLTYPE         0xf     /* Mask for the type */
-#define CTLTYPE_NODE    1       /* name is a node */
-#define CTLTYPE_INT     2       /* name describes an integer */
-#define CTLTYPE_STRING  3       /* name describes a string */
-#define CTLTYPE_QUAD    4       /* name describes a 64-bit number */
-#define CTLTYPE_OPAQUE  5       /* name describes a structure */
-#define CTLTYPE_STRUCT  CTLTYPE_OPAQUE  /* name describes a structure */
+#define CTLTYPE             0xf             /* Mask for the type */
+#define CTLTYPE_NODE        1               /* name is a node */
+#define CTLTYPE_INT         2               /* name describes an integer */
+#define CTLTYPE_STRING      3               /* name describes a string */
+#define CTLTYPE_QUAD        4               /* name describes a 64-bit number */
+#define CTLTYPE_OPAQUE      5               /* name describes a structure */
+#define CTLTYPE_STRUCT      CTLTYPE_OPAQUE  /* name describes a structure */
 
-#define CTLFLAG_RD      0x80000000      /* Allow reads of variable */
-#define CTLFLAG_WR      0x40000000      /* Allow writes to the variable */
-#define CTLFLAG_RW      (CTLFLAG_RD|CTLFLAG_WR)
-#define CTLFLAG_NOLOCK  0x20000000      /* XXX Don't Lock */
-#define CTLFLAG_ANYBODY 0x10000000      /* All users can set this var */
-#define CTLFLAG_SECURE  0x08000000      /* Permit set only if securelevel<=0 */
-#define CTLFLAG_MASKED  0x04000000      /* deprecated variable, do not display */
-#define CTLFLAG_NOAUTO  0x02000000      /* do not auto-register */
-#define CTLFLAG_KERN    0x01000000      /* valid inside the kernel */
-#define CTLFLAG_LOCKED  0x00800000      /* node will handle locking itself */
-#define CTLFLAG_OID2    0x00400000      /* struct sysctl_oid has version info */
+#define CTLFLAG_RD          0x80000000      /* Allow reads of variable */
+#define CTLFLAG_WR          0x40000000      /* Allow writes to the variable */
+#define CTLFLAG_RW          (CTLFLAG_RD|CTLFLAG_WR)
+#define CTLFLAG_NOLOCK      0x20000000      /* XXX Don't Lock */
+#define CTLFLAG_ANYBODY     0x10000000      /* All users can set this var */
+#define CTLFLAG_SECURE      0x08000000      /* Permit set only if securelevel<=0 */
+#define CTLFLAG_MASKED      0x04000000      /* deprecated variable, do not display */
+#define CTLFLAG_NOAUTO      0x02000000      /* do not auto-register */
+#define CTLFLAG_KERN        0x01000000      /* valid inside the kernel */
+#define CTLFLAG_LOCKED      0x00800000      /* node will handle locking itself */
+#define CTLFLAG_OID2        0x00400000      /* struct sysctl_oid has version info */
+#define CTLFLAG_EXPERIMENT 0x00100000 /* Allows writing w/ the trial experiment entitlement. */
 
 /*
  * USE THIS instead of a hardwired number from the categories below
@@ -168,8 +169,8 @@ struct ctlname {
  * in I/O-Kit. In this case, you have to call sysctl_register_oid()
  * manually - just like in a KEXT.
  */
-#define OID_AUTO        (-1)
-#define OID_AUTO_START 100 /* conventional */
+#define OID_AUTO              (-1)
+#define OID_AUTO_START        100 /* conventional */
 
 
 #define SYSCTL_DEF_ENABLED
@@ -228,7 +229,7 @@ struct ctlname {
 #define KERN_NISDOMAINNAME      22      /* string: YP domain name */
 #define KERN_DOMAINNAME         KERN_NISDOMAINNAME
 #define KERN_MAXPARTITIONS      23      /* int: number of partitions/disk */
-#define KERN_KDEBUG                     24      /* int: kernel trace points */
+#define KERN_KDEBUG             24      /* int: kernel trace points */
 #define KERN_UPDATEINTERVAL     25      /* int: update process sleep time */
 #define KERN_OSRELDATE          26      /* int: OS release date */
 #define KERN_NTP_PLL            27      /* node: NTP PLL control */
@@ -337,8 +338,9 @@ struct ctlname {
 #define KERN_KDSET_TYPEFILTER 22
 #define KERN_KDBUFWAIT        23
 #define KERN_KDCPUMAP         24
-/* 25 - 26 unused */
-#define KERN_KDWRITEMAP_V3    27
+#define KERN_KDCPUMAP_EXT     25
+#define KERN_KDSET_EDM        26
+#define KERN_KDGET_EDM        27
 #define KERN_KDWRITETR_V3     28
 
 #define CTL_KERN_NAMES { \
@@ -553,8 +555,8 @@ extern struct loadavg averunnable;
 /*
  * CTL_HW identifiers
  */
-#define HW_MACHINE       1              /* string: machine class */
-#define HW_MODEL         2              /* string: specific machine model */
+#define HW_MACHINE       1              /* string: machine class (deprecated: use HW_PRODUCT) */
+#define HW_MODEL         2              /* string: specific machine model (deprecated: use HW_TARGET) */
 #define HW_NCPU          3              /* int: number of cpus */
 #define HW_BYTEORDER     4              /* int: machine byte order */
 #define HW_PHYSMEM       5              /* int: total memory */
@@ -578,12 +580,14 @@ extern struct loadavg averunnable;
 #define HW_TB_FREQ      23              /* int: Bus Frequency */
 #define HW_MEMSIZE      24              /* uint64_t: physical ram size */
 #define HW_AVAILCPU     25              /* int: number of available CPUs */
-#define HW_MAXID        26              /* number of valid hw ids */
+#define HW_TARGET       26              /* string: model identifier */
+#define HW_PRODUCT      27              /* string: product identifier */
+#define HW_MAXID        28              /* number of valid hw ids */
 
 #define CTL_HW_NAMES { \
 	{ 0, 0 }, \
-	{ "machine", CTLTYPE_STRING }, \
-	{ "model", CTLTYPE_STRING }, \
+	{ "machine", CTLTYPE_STRING },          /* Deprecated: use hw.product */ \
+	{ "model", CTLTYPE_STRING },            /* Deprecated: use hw.target */ \
 	{ "ncpu", CTLTYPE_INT }, \
 	{ "byteorder", CTLTYPE_INT }, \
 	{ "physmem", CTLTYPE_INT }, \
@@ -606,7 +610,9 @@ extern struct loadavg averunnable;
 	{ "l3cachesize", CTLTYPE_INT }, \
 	{ "tbfrequency", CTLTYPE_INT }, \
 	{ "memsize", CTLTYPE_QUAD }, \
-	{ "availcpu", CTLTYPE_INT } \
+	{ "availcpu", CTLTYPE_INT }, \
+	{ "target", CTLTYPE_STRING }, \
+	{ "product", CTLTYPE_STRING }, \
 }
 
 /*
@@ -663,6 +669,28 @@ extern struct loadavg averunnable;
  *   hw.l2cachesize            -
  *   hw.l3cachesize            -
  *
+ *   hw.nperflevels            - Number of core types in the system. See the parameters below, which can be used to get
+ *                             - information associated with a specific perf level.
+ *
+ *   The following parameters apply to perflevel N, where N is a number between 0 and the number of core types in the system minus one.
+ *   perflevel 0 always refers to the highest performance core type in the system.
+ *
+ *   hw.perflevelN.physicalcpu      - The number of physical processors available in the current power management mode.
+ *   hw.perflevelN.physicalcpumax   - The maximum number of physical processors that could be available this boot.
+ *   hw.perflevelN.logicalcpu       - The number of logical processors available in the current power management mode.
+ *   hw.perflevelN.logicalcpumax    - The maximum number of logical processors that could be available this boot.
+ *
+ *   hw.perflevelN.l1dcachesize     - These values provide the size in bytes of the L1, L2 and L3 caches.  If a cache is not present
+ *   hw.perflevelN.l1icachesize     - then the selector will return and error.
+ *   hw.perflevelN.l2cachesize      -
+ *   hw.perflevelN.l3cachesize      -
+ *
+ *   hw.perflevelN.cpusperl2        - These values provide the number of CPUs of the same type that share L2 and L3 caches.
+ *   hw.perflevelN.cpusperl3        - If a cache is not present then the selector will return and error.
+ *
+ *   hw.perflevelN.l2perflevels     - These values provide a bitmap, where bit  number of CPUs of the same type that share L2 and L3 caches.
+ *   hw.perflevelN.l3perflevels     - If a cache is not present then the selector will return and error.
+ *
  *   hw.packages               - Gives the number of processor packages.
  *
  * These are the selectors for optional processor features for specific processors.  Selectors that return errors are not support
@@ -755,7 +783,7 @@ extern struct loadavg averunnable;
 #define CTL_DEBUG_MAXID         20
 
 
-#if (CTL_MAXID != 9) || (KERN_MAXID != 72) || (VM_MAXID != 6) || (HW_MAXID != 26) || (USER_MAXID != 21) || (CTL_DEBUG_MAXID != 20)
+#if (CTL_MAXID != 9) || (KERN_MAXID != 72) || (VM_MAXID != 6) || (HW_MAXID != 28) || (USER_MAXID != 21) || (CTL_DEBUG_MAXID != 20)
 #error Use the SYSCTL_*() macros and OID_AUTO instead!
 #endif
 
diff --git a/lib/libc/include/any-macos.13-any/sys/time.h b/lib/libc/include/any-macos.13-any/sys/time.h
new file mode 100644
index 0000000000..5e8da98d4b
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/sys/time.h
@@ -0,0 +1,210 @@
+/*
+ * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
+/*
+ * Copyright (c) 1982, 1986, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)time.h	8.2 (Berkeley) 7/10/94
+ */
+
+#ifndef _SYS_TIME_H_
+#define _SYS_TIME_H_
+
+#include <sys/cdefs.h>
+#include <sys/_types.h>
+#include <Availability.h>
+
+
+/*
+ * [XSI] The fd_set type shall be defined as described in <sys/select.h>.
+ * The timespec structure shall be defined as described in <time.h>
+ */
+#include <sys/_types/_fd_def.h>
+#include <sys/_types/_timespec.h>
+#include <sys/_types/_timeval.h>
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+#include <sys/_types/_timeval64.h>
+#endif /* !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE) */
+
+
+#include <sys/_types/_time_t.h>
+#include <sys/_types/_suseconds_t.h>
+
+/*
+ * Structure used as a parameter by getitimer(2) and setitimer(2) system
+ * calls.
+ */
+struct  itimerval {
+	struct  timeval it_interval;    /* timer interval */
+	struct  timeval it_value;       /* current value */
+};
+
+/*
+ * Names of the interval timers, and structure
+ * defining a timer setting.
+ */
+#define ITIMER_REAL     0
+#define ITIMER_VIRTUAL  1
+#define ITIMER_PROF     2
+
+/*
+ * Select uses bit masks of file descriptors in longs.  These macros
+ * manipulate such bit fields (the filesystem macros use chars).  The
+ * extra protection here is to permit application redefinition above
+ * the default size.
+ */
+#include <sys/_types/_fd_setsize.h>
+#include <sys/_types/_fd_set.h>
+#include <sys/_types/_fd_clr.h>
+#include <sys/_types/_fd_isset.h>
+#include <sys/_types/_fd_zero.h>
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+
+#include <sys/_types/_fd_copy.h>
+
+#define TIMEVAL_TO_TIMESPEC(tv, ts) {                                   \
+	(ts)->tv_sec = (tv)->tv_sec;                                    \
+	(ts)->tv_nsec = (tv)->tv_usec * 1000;                           \
+}
+#define TIMESPEC_TO_TIMEVAL(tv, ts) {                                   \
+	(tv)->tv_sec = (ts)->tv_sec;                                    \
+	(tv)->tv_usec = (ts)->tv_nsec / 1000;                           \
+}
+
+struct timezone {
+	int     tz_minuteswest; /* minutes west of Greenwich */
+	int     tz_dsttime;     /* type of dst correction */
+};
+#define DST_NONE        0       /* not on dst */
+#define DST_USA         1       /* USA style dst */
+#define DST_AUST        2       /* Australian style dst */
+#define DST_WET         3       /* Western European dst */
+#define DST_MET         4       /* Middle European dst */
+#define DST_EET         5       /* Eastern European dst */
+#define DST_CAN         6       /* Canada */
+
+/* Operations on timevals. */
+#define timerclear(tvp)         (tvp)->tv_sec = (tvp)->tv_usec = 0
+#define timerisset(tvp)         ((tvp)->tv_sec || (tvp)->tv_usec)
+#define timercmp(tvp, uvp, cmp)                                         \
+	(((tvp)->tv_sec == (uvp)->tv_sec) ?                             \
+	    ((tvp)->tv_usec cmp (uvp)->tv_usec) :                       \
+	    ((tvp)->tv_sec cmp (uvp)->tv_sec))
+#define timeradd(tvp, uvp, vvp)                                         \
+	do {                                                            \
+	        (vvp)->tv_sec = (tvp)->tv_sec + (uvp)->tv_sec;          \
+	        (vvp)->tv_usec = (tvp)->tv_usec + (uvp)->tv_usec;       \
+	        if ((vvp)->tv_usec >= 1000000) {                        \
+	                (vvp)->tv_sec++;                                \
+	                (vvp)->tv_usec -= 1000000;                      \
+	        }                                                       \
+	} while (0)
+#define timersub(tvp, uvp, vvp)                                         \
+	do {                                                            \
+	        (vvp)->tv_sec = (tvp)->tv_sec - (uvp)->tv_sec;          \
+	        (vvp)->tv_usec = (tvp)->tv_usec - (uvp)->tv_usec;       \
+	        if ((vvp)->tv_usec < 0) {                               \
+	                (vvp)->tv_sec--;                                \
+	                (vvp)->tv_usec += 1000000;                      \
+	        }                                                       \
+	} while (0)
+
+#define timevalcmp(l, r, cmp)   timercmp(l, r, cmp) /* freebsd */
+
+/*
+ * Getkerninfo clock information structure
+ */
+struct clockinfo {
+	int     hz;             /* clock frequency */
+	int     tick;           /* micro-seconds per hz tick */
+	int     tickadj;        /* clock skew rate for adjtime() */
+	int     stathz;         /* statistics clock frequency */
+	int     profhz;         /* profiling clock frequency */
+};
+#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
+
+
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+#include <time.h>
+#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
+
+__BEGIN_DECLS
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+int     adjtime(const struct timeval *, struct timeval *);
+int     futimes(int, const struct timeval *);
+int     lutimes(const char *, const struct timeval *) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
+int     settimeofday(const struct timeval *, const struct timezone *);
+#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
+
+int     getitimer(int, struct itimerval *);
+int     gettimeofday(struct timeval * __restrict, void * __restrict);
+
+#include <sys/_select.h>        /* select() prototype */
+
+int     setitimer(int, const struct itimerval * __restrict,
+    struct itimerval * __restrict);
+int     utimes(const char *, const struct timeval *);
+
+__END_DECLS
+
+
+
+#endif /* !_SYS_TIME_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/sys/types.h b/lib/libc/include/any-macos.13-any/sys/types.h
new file mode 100644
index 0000000000..a6be64c82f
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/sys/types.h
@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) 2000-2021 Apple Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
+/*
+ * Copyright (c) 1982, 1986, 1991, 1993, 1994
+ *	The Regents of the University of California.  All rights reserved.
+ * (c) UNIX System Laboratories, Inc.
+ * All or some portions of this file are derived from material licensed
+ * to the University of California by American Telephone and Telegraph
+ * Co. or Unix System Laboratories, Inc. and are reproduced herein with
+ * the permission of UNIX System Laboratories, Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)types.h	8.4 (Berkeley) 1/21/94
+ */
+
+#ifndef _SYS_TYPES_H_
+#define _SYS_TYPES_H_
+
+#include <sys/appleapiopts.h>
+
+#ifndef __ASSEMBLER__
+#include <sys/cdefs.h>
+
+/* Machine type dependent parameters. */
+#include <machine/types.h>
+#include <sys/_types.h>
+
+#include <machine/endian.h>
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+#include <sys/_types/_u_char.h>
+#include <sys/_types/_u_short.h>
+#include <sys/_types/_u_int.h>
+#ifndef _U_LONG
+typedef unsigned long           u_long;
+#define _U_LONG
+#endif
+typedef unsigned short          ushort;         /* Sys V compatibility */
+typedef unsigned int            uint;           /* Sys V compatibility */
+#endif
+
+typedef u_int64_t               u_quad_t;       /* quads */
+typedef int64_t                 quad_t;
+typedef quad_t *                qaddr_t;
+
+#include <sys/_types/_caddr_t.h>        /* core address */
+
+typedef int32_t                 daddr_t;        /* disk address */
+
+#include <sys/_types/_dev_t.h>                  /* device number */
+
+typedef u_int32_t               fixpt_t;        /* fixed point number */
+
+#include <sys/_types/_blkcnt_t.h>
+#include <sys/_types/_blksize_t.h>
+#include <sys/_types/_gid_t.h>
+#include <sys/_types/_in_addr_t.h>
+#include <sys/_types/_in_port_t.h>
+#include <sys/_types/_ino_t.h>
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+#include <sys/_types/_ino64_t.h>                        /* 64bit inode number */
+#endif /* !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE) */
+
+#include <sys/_types/_key_t.h>
+#include <sys/_types/_mode_t.h>
+#include <sys/_types/_nlink_t.h>
+#include <sys/_types/_id_t.h>
+#include <sys/_types/_pid_t.h>
+#include <sys/_types/_off_t.h>
+
+typedef int32_t                 segsz_t;        /* segment size */
+typedef int32_t                 swblk_t;        /* swap offset */
+
+#include <sys/_types/_uid_t.h>
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+/* Major, minor numbers, dev_t's. */
+#if defined(__cplusplus)
+/*
+ * These lowercase macros tend to match member functions in some C++ code,
+ * so for C++, we must use inline functions instead.
+ */
+
+static inline __int32_t
+major(__uint32_t _x)
+{
+	return (__int32_t)(((__uint32_t)_x >> 24) & 0xff);
+}
+
+static inline __int32_t
+minor(__uint32_t _x)
+{
+	return (__int32_t)((_x) & 0xffffff);
+}
+
+static inline dev_t
+makedev(__uint32_t _major, __uint32_t _minor)
+{
+	return (dev_t)(((_major) << 24) | (_minor));
+}
+
+#else   /* !__cplusplus */
+
+#define major(x)        ((int32_t)(((u_int32_t)(x) >> 24) & 0xff))
+#define minor(x)        ((int32_t)((x) & 0xffffff))
+#define makedev(x, y)    ((dev_t)(((x) << 24) | (y)))
+
+#endif  /* !__cplusplus */
+#endif  /* !_POSIX_C_SOURCE */
+
+#include <sys/_types/_clock_t.h>
+#include <sys/_types/_size_t.h>
+#include <sys/_types/_ssize_t.h>
+#include <sys/_types/_time_t.h>
+
+#include <sys/_types/_useconds_t.h>
+#include <sys/_types/_suseconds_t.h>
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+#include <sys/_types/_rsize_t.h>
+#include <sys/_types/_errno_t.h>
+#endif
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+/*
+ * This code is present here in order to maintain historical backward
+ * compatability, and is intended to be removed at some point in the
+ * future; please include <sys/select.h> instead.
+ */
+#include <sys/_types/_fd_def.h>
+
+#define NBBY            __DARWIN_NBBY           /* bits in a byte */
+#define NFDBITS         __DARWIN_NFDBITS        /* bits per mask */
+#define howmany(x, y)   __DARWIN_howmany(x, y)  /* # y's == x bits? */
+typedef __int32_t       fd_mask;
+
+/*
+ * Select uses bit masks of file descriptors in longs.  These macros
+ * manipulate such bit fields (the filesystem macros use chars).  The
+ * extra protection here is to permit application redefinition above
+ * the default size.
+ */
+#include <sys/_types/_fd_setsize.h>
+#include <sys/_types/_fd_set.h>
+#include <sys/_types/_fd_clr.h>
+#include <sys/_types/_fd_zero.h>
+#include <sys/_types/_fd_isset.h>
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+#include <sys/_types/_fd_copy.h>
+#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
+
+
+
+#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
+#endif /* __ASSEMBLER__ */
+
+
+#ifndef __POSIX_LIB__
+
+#include <sys/_pthread/_pthread_attr_t.h>
+#include <sys/_pthread/_pthread_cond_t.h>
+#include <sys/_pthread/_pthread_condattr_t.h>
+#include <sys/_pthread/_pthread_mutex_t.h>
+#include <sys/_pthread/_pthread_mutexattr_t.h>
+#include <sys/_pthread/_pthread_once_t.h>
+#include <sys/_pthread/_pthread_rwlock_t.h>
+#include <sys/_pthread/_pthread_rwlockattr_t.h>
+#include <sys/_pthread/_pthread_t.h>
+
+#endif /* __POSIX_LIB__ */
+
+#include <sys/_pthread/_pthread_key_t.h>
+
+
+/* statvfs and fstatvfs */
+
+#include <sys/_types/_fsblkcnt_t.h>
+#include <sys/_types/_fsfilcnt_t.h>
+
+#endif /* !_SYS_TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/sys/unistd.h b/lib/libc/include/any-macos.13-any/sys/unistd.h
new file mode 100644
index 0000000000..78c93998f7
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/sys/unistd.h
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2000-2013 Apple Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
+/*
+ * Copyright (c) 1989, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)unistd.h	8.2 (Berkeley) 1/7/94
+ */
+
+#ifndef _SYS_UNISTD_H_
+#define _SYS_UNISTD_H_
+
+#include <sys/cdefs.h>
+
+/*
+ * Although we have saved user/group IDs, we do not use them in setuid
+ * as described in POSIX 1003.1, because the feature does not work for
+ * root.  We use the saved IDs in seteuid/setegid, which are not currently
+ * part of the POSIX 1003.1 specification.
+ */
+#ifdef  _NOT_AVAILABLE
+#define _POSIX_SAVED_IDS        /* saved set-user-ID and set-group-ID */
+#endif
+
+#define _POSIX_VERSION          200112L
+#define _POSIX2_VERSION         200112L
+
+/* execution-time symbolic constants */
+/* may disable terminal special characters */
+#include <sys/_types/_posix_vdisable.h>
+
+#define _POSIX_THREAD_KEYS_MAX 128
+
+/* access function */
+#define F_OK            0       /* test for existence of file */
+#define X_OK            (1<<0)  /* test for execute or search permission */
+#define W_OK            (1<<1)  /* test for write permission */
+#define R_OK            (1<<2)  /* test for read permission */
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+/*
+ * Extended access functions.
+ * Note that we depend on these matching the definitions in sys/kauth.h,
+ * but with the bits shifted left by 8.
+ */
+#define _READ_OK        (1<<9)  /* read file data / read directory */
+#define _WRITE_OK       (1<<10) /* write file data / add file to directory */
+#define _EXECUTE_OK     (1<<11) /* execute file / search in directory*/
+#define _DELETE_OK      (1<<12) /* delete file / delete directory */
+#define _APPEND_OK      (1<<13) /* append to file / add subdirectory to directory */
+#define _RMFILE_OK      (1<<14) /* - / remove file from directory */
+#define _RATTR_OK       (1<<15) /* read basic attributes */
+#define _WATTR_OK       (1<<16) /* write basic attributes */
+#define _REXT_OK        (1<<17) /* read extended attributes */
+#define _WEXT_OK        (1<<18) /* write extended attributes */
+#define _RPERM_OK       (1<<19) /* read permissions */
+#define _WPERM_OK       (1<<20) /* write permissions */
+#define _CHOWN_OK       (1<<21) /* change ownership */
+
+#define _ACCESS_EXTENDED_MASK (_READ_OK | _WRITE_OK | _EXECUTE_OK | \
+	                        _DELETE_OK | _APPEND_OK | \
+	                        _RMFILE_OK | _REXT_OK | \
+	                        _WEXT_OK | _RATTR_OK | _WATTR_OK | _RPERM_OK | \
+	                        _WPERM_OK | _CHOWN_OK)
+#endif
+
+/* whence values for lseek(2) */
+#include <sys/_types/_seek_set.h>
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+/* whence values for lseek(2); renamed by POSIX 1003.1 */
+#define L_SET           SEEK_SET
+#define L_INCR          SEEK_CUR
+#define L_XTND          SEEK_END
+#endif
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+struct accessx_descriptor {
+	unsigned int ad_name_offset;
+	int ad_flags;
+	int ad_pad[2];
+};
+#define ACCESSX_MAX_DESCRIPTORS 100
+#define ACCESSX_MAX_TABLESIZE   (16 * 1024)
+#endif
+
+/* configurable pathname variables */
+#define _PC_LINK_MAX             1
+#define _PC_MAX_CANON            2
+#define _PC_MAX_INPUT            3
+#define _PC_NAME_MAX             4
+#define _PC_PATH_MAX             5
+#define _PC_PIPE_BUF             6
+#define _PC_CHOWN_RESTRICTED     7
+#define _PC_NO_TRUNC             8
+#define _PC_VDISABLE             9
+
+#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
+#define _PC_NAME_CHARS_MAX       10
+#define _PC_CASE_SENSITIVE               11
+#define _PC_CASE_PRESERVING              12
+#define _PC_EXTENDED_SECURITY_NP        13
+#define _PC_AUTH_OPAQUE_NP      14
+#endif
+
+#define _PC_2_SYMLINKS          15      /* Symlink supported in directory */
+#define _PC_ALLOC_SIZE_MIN      16      /* Minimum storage actually allocated */
+#define _PC_ASYNC_IO            17      /* Async I/O [AIO] supported? */
+#define _PC_FILESIZEBITS        18      /* # of bits to represent file size */
+#define _PC_PRIO_IO             19      /* Priority I/O [PIO] supported? */
+#define _PC_REC_INCR_XFER_SIZE  20      /* Recommended increment for next two */
+#define _PC_REC_MAX_XFER_SIZE   21      /* Recommended max file transfer size */
+#define _PC_REC_MIN_XFER_SIZE   22      /* Recommended min file transfer size */
+#define _PC_REC_XFER_ALIGN      23      /* Recommended buffer alignment */
+#define _PC_SYMLINK_MAX         24      /* Max # of bytes in symlink name */
+#define _PC_SYNC_IO             25      /* Sync I/O [SIO] supported? */
+#define _PC_XATTR_SIZE_BITS     26      /* # of bits to represent maximum xattr size */
+#define _PC_MIN_HOLE_SIZE       27      /* Recommended minimum hole size for sparse files */
+
+/* configurable system strings */
+#define _CS_PATH                 1
+
+#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
+
+#include <machine/_types.h>
+#include <sys/_types/_size_t.h>
+#include <sys/_types/_ssize_t.h>
+#include <_types/_uint64_t.h>
+#include <_types/_uint32_t.h>
+#include <Availability.h>
+
+__BEGIN_DECLS
+
+int     getattrlistbulk(int, void *, void *, size_t, uint64_t) __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
+int     getattrlistat(int, const char *, void *, void *, size_t, unsigned long) __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
+int     setattrlistat(int, const char *, void *, void *, size_t, uint32_t) __OSX_AVAILABLE(10.13) __IOS_AVAILABLE(11.0) __TVOS_AVAILABLE(11.0) __WATCHOS_AVAILABLE(4.0);
+ssize_t freadlink(int, char * __restrict, size_t) __API_AVAILABLE(macos(13.0), ios(16.0), tvos(16.0), watchos(9.0));
+
+__END_DECLS
+
+#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
+
+#if __DARWIN_C_LEVEL >= 200809L
+
+#include <machine/_types.h>
+#include <sys/_types/_size_t.h>
+#include <sys/_types/_ssize_t.h>
+#include <sys/_types.h>
+#include <sys/_types/_uid_t.h>
+#include <sys/_types/_gid_t.h>
+#include <Availability.h>
+
+__BEGIN_DECLS
+
+int     faccessat(int, const char *, int, int) __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
+int     fchownat(int, const char *, uid_t, gid_t, int)  __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
+int     linkat(int, const char *, int, const char *, int)       __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
+ssize_t readlinkat(int, const char *, char *, size_t)   __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
+int     symlinkat(const char *, int, const char *) __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
+int     unlinkat(int, const char *, int) __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
+
+__END_DECLS
+
+#endif /* __DARWIN_C_LEVEL >= 200809L */
+
+#endif /* !_SYS_UNISTD_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/xpc/base.h b/lib/libc/include/any-macos.13-any/xpc/base.h
similarity index 83%
rename from lib/libc/include/x86_64-macos.10-none/xpc/base.h
rename to lib/libc/include/any-macos.13-any/xpc/base.h
index 8fce33a1d4..34687cb583 100644
--- a/lib/libc/include/x86_64-macos.10-none/xpc/base.h
+++ b/lib/libc/include/any-macos.13-any/xpc/base.h
@@ -29,6 +29,8 @@ __BEGIN_DECLS
 #include <Availability.h>
 #endif // __has_include(<xpc/availability.h>)
 
+#include <os/availability.h>
+
 #ifndef __XPC_INDIRECT__
 #error "Please #include <xpc/xpc.h> instead of this file directly."
 #endif // __XPC_INDIRECT__ 
@@ -83,7 +85,10 @@ __BEGIN_DECLS
 #define XPC_DEPRECATED(m) __attribute__((deprecated(m)))
 #else // __clang__
 #define XPC_DEPRECATED(m) __attribute__((deprecated))
-#endif // __clang 
+#endif // __clang
+#ifndef XPC_TESTEXPORT
+#define XPC_TESTEXPORT XPC_NOEXPORT
+#endif // XPC_TESTEXPORT
 
 #if defined(__XPC_TEST__) && __XPC_TEST__
 #define XPC_TESTSTATIC
@@ -190,6 +195,28 @@ __BEGIN_DECLS
 #define XPC_NONNULL_ARRAY
 #endif
 
+#if defined(__has_ptrcheck) && __has_ptrcheck
+#define XPC_PTR_ASSUMES_SINGLE __ptrcheck_abi_assume_single()
+#define XPC_SINGLE __single
+#define XPC_UNSAFE_INDEXABLE __unsafe_indexable
+#define XPC_CSTRING XPC_UNSAFE_INDEXABLE
+#define XPC_SIZEDBY(N) __sized_by(N)
+#define XPC_COUNTEDBY(N) __counted_by(N)
+#define XPC_UNSAFE_FORGE_SIZED_BY(_type, _ptr, _size) \
+		__unsafe_forge_bidi_indexable(_type, _ptr, _size)
+#define XPC_UNSAFE_FORGE_SINGLE(_type, _ptr) \
+		__unsafe_forge_single(_type, _ptr)
+#else // defined(__has_ptrcheck) ** __has_ptrcheck
+#define XPC_PTR_ASSUMES_SINGLE
+#define XPC_SINGLE
+#define XPC_UNSAFE_INDEXABLE
+#define XPC_CSTRING
+#define XPC_SIZEDBY(N)
+#define XPC_COUNTEDBY(N)
+#define XPC_UNSAFE_FORGE_SIZED_BY(_type, _ptr, _size) ((_type)(_ptr))
+#define XPC_UNSAFE_FORGE_SINGLE(_type, _ptr) ((_type)(_ptr))
+#endif // defined(__has_ptrcheck) ** __has_ptrcheck
+
 #ifdef OS_CLOSED_OPTIONS
 #define XPC_FLAGS_ENUM(_name, _type, ...) \
 		OS_CLOSED_OPTIONS(_name, _type, __VA_ARGS__)
@@ -206,6 +233,12 @@ __BEGIN_DECLS
 		OS_ENUM(_name, _type, __VA_ARGS__)
 #endif // OS_CLOSED_ENUM
 
+#if __has_attribute(swift_name)
+# define XPC_SWIFT_NAME(_name) __attribute__((swift_name(_name)))
+#else
+# define XPC_SWIFT_NAME(_name) // __has_attribute(swift_name)
+#endif
+
 __END_DECLS
 
 #endif // __XPC_BASE_H__
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/xpc/connection.h b/lib/libc/include/any-macos.13-any/xpc/connection.h
similarity index 92%
rename from lib/libc/include/x86_64-macos.10-none/xpc/connection.h
rename to lib/libc/include/any-macos.13-any/xpc/connection.h
index 7a6ac1a2f9..ac89af4e45 100644
--- a/lib/libc/include/x86_64-macos.10-none/xpc/connection.h
+++ b/lib/libc/include/any-macos.13-any/xpc/connection.h
@@ -79,6 +79,20 @@ __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
 XPC_EXPORT
 const struct _xpc_dictionary_s _xpc_error_termination_imminent;
 
+/*!
+ * @constant XPC_ERROR_PEER_CODE_SIGNING_REQUIREMENT
+ * On macOS, this error will be delivered to a peer connection's event handler
+ * when the XPC runtime has detected that a peer connection does not
+ * satisfy the code signing requirement specified for the connection.
+ *
+ * See {@link xpc_connection_set_peer_code_signing_requirement}
+ */
+#define XPC_ERROR_PEER_CODE_SIGNING_REQUIREMENT \
+	XPC_GLOBAL_OBJECT(_xpc_error_peer_code_signing_requirement)
+__API_AVAILABLE(macos(12.0))
+XPC_EXPORT
+const struct _xpc_dictionary_s _xpc_error_peer_code_signing_requirement;
+
 /*!
  * @constant XPC_CONNECTION_MACH_SERVICE_LISTENER
  * Passed to xpc_connection_create_mach_service(). This flag indicates that the
@@ -243,7 +257,7 @@ xpc_connection_create_from_endpoint(xpc_endpoint_t endpoint);
  *
  * Despite this seeming inconsistency, the XPC runtime guarantees that, when the
  * target queue is a serial queue, the event handler block will execute
- * synchonously with respect to other blocks submitted to that same queue. When
+ * synchronously with respect to other blocks submitted to that same queue. When
  * the target queue is a concurrent queue, the event handler block may run
  * concurrently with other blocks submitted to that queue, but it will never run
  * concurrently with other invocations of itself for the same connection, as
@@ -507,7 +521,7 @@ xpc_connection_send_barrier(xpc_connection_t connection,
  * @discussion
  * If the given GCD queue is a concurrent queue, XPC cannot guarantee that there
  * will not be multiple reply handlers being invoked concurrently. XPC does not
- * guarantee any ordering for the invocation of reply handers. So if multiple
+ * guarantee any ordering for the invocation of reply handlers. So if multiple
  * messages are waiting for replies and the connection goes invalid, there is no
  * guarantee that the reply handlers will be invoked in FIFO order. Similarly,
  * XPC does not guarantee that reply handlers will not run concurrently with
@@ -542,10 +556,11 @@ xpc_connection_send_message_with_reply(xpc_connection_t connection,
  * You are responsible for releasing the returned object.
  *
  * @discussion
- * This API is primarily for transitional purposes. Its implementation is
- * conceptually equivalent to calling xpc_connection_send_message_with_reply()
- * and then immediately blocking the calling thread on a semaphore and
- * signaling the semaphore from the reply block.
+ * This API supports priority inversion avoidance, and should be used instead of
+ * combining xpc_connection_send_message_with_reply() with a semaphore.
+ *
+ * Invoking this API from a queue that is a part of the target queue hierarchy
+ * results in deadlocks under certain conditions.
  *
  * Be judicious about your use of this API. It can block indefinitely, so if you
  * are using it to implement an API that can be called from the main thread, you
@@ -741,6 +756,40 @@ void
 xpc_connection_set_finalizer_f(xpc_connection_t connection,
 	xpc_finalizer_t _Nullable finalizer);
 
+/*!
+ * @function xpc_connection_set_peer_code_signing_requirement
+ * Requires that the connection peer satisfies a code signing requirement.
+ *
+ * @param connection
+ * The connection object which is to be modified.
+ *
+ * @param requirement
+ * The code signing requirement to be satisfied by the peer
+ * It is safe to deallocate the requirement string after calling `xpc_connection_set_peer_code_signing_requirement`
+ *
+ * @result
+ * 0 on success, non-zero on error
+ *
+ * @discussion
+ * This function will return an error promptly if the code signing requirement string is invalid.
+ *
+ * It is a programming error to call `xpc_connection_set_peer_code_signing_requirement` more than once per connection.
+ *
+ * All messages received on this connection will be checked to ensure they come from a peer who satisfies
+ * the code signing requirement. For a listener connection, requests that do not satisfy the requirement
+ * are dropped. When a reply is expected on the connection and the peer does not satisfy the requirement
+ * XPC_ERROR_PEER_CODE_SIGNING_REQUIREMENT will be delivered instead of the reply.
+ *
+ * This API is not supported on embedded platforms and will return ENOTSUP. 
+ *
+ * @see https://developer.apple.com/library/archive/documentation/Security/Conceptual/CodeSigningGuide/RequirementLang/RequirementLang.html
+ */
+__API_AVAILABLE(macos(12.0))
+XPC_EXPORT XPC_NONNULL_ALL XPC_WARN_RESULT
+int
+xpc_connection_set_peer_code_signing_requirement(xpc_connection_t connection, const char *requirement);
+
+
 __END_DECLS
 XPC_ASSUME_NONNULL_END
 
diff --git a/lib/libc/include/any-macos.13-any/xpc/rich_error.h b/lib/libc/include/any-macos.13-any/xpc/rich_error.h
new file mode 100644
index 0000000000..bea5c9a19f
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/xpc/rich_error.h
@@ -0,0 +1,52 @@
+#ifndef __XPC_RICH_ERROR_H__
+#define __XPC_RICH_ERROR_H__
+
+#ifndef __XPC_INDIRECT__
+#error "Please #include <xpc/xpc.h> instead of this file directly."
+// For HeaderDoc.
+#include <xpc/base.h>
+#endif // __XPC_INDIRECT__
+
+#ifndef __BLOCKS__
+#error "XPC Rich Errors require Blocks support."
+#endif // __BLOCKS__
+
+XPC_ASSUME_NONNULL_BEGIN
+__BEGIN_DECLS
+
+#pragma mark Properties
+/*!
+ * @function xpc_rich_error_copy_description
+ * Copy the string description of an error.
+ *
+ * @param error
+ * The error to be examined.
+ *
+ * @result
+ * The underlying C string for the provided error. This string should be
+ * disposed of with free(3) when done.
+ * 
+ * This will return NULL if a string description could not be generated.
+ */
+XPC_EXPORT XPC_WARN_RESULT
+char * _Nullable
+xpc_rich_error_copy_description(xpc_rich_error_t error);
+
+/*!
+ * @function xpc_rich_error_can_retry
+ * Whether the operation the error originated from can be retried.
+ *
+ * @param error
+ * The error to be inspected.
+ *
+ * @result
+ * Whether the operation the error originated from can be retried.
+ */
+XPC_EXPORT XPC_WARN_RESULT
+bool
+xpc_rich_error_can_retry(xpc_rich_error_t error);
+
+__END_DECLS
+XPC_ASSUME_NONNULL_END
+
+#endif // __XPC_RICH_ERROR_H__
\ No newline at end of file
diff --git a/lib/libc/include/any-macos.13-any/xpc/session.h b/lib/libc/include/any-macos.13-any/xpc/session.h
new file mode 100644
index 0000000000..82885546ff
--- /dev/null
+++ b/lib/libc/include/any-macos.13-any/xpc/session.h
@@ -0,0 +1,346 @@
+#ifndef __XPC_SESSION_H__
+#define __XPC_SESSION_H__
+
+#ifndef __XPC_INDIRECT__
+#error "Please #include <xpc/xpc.h> instead of this file directly."
+// For HeaderDoc.
+#include <xpc/base.h>
+#endif // __XPC_INDIRECT__
+
+#ifndef __BLOCKS__
+#error "XPC Session require Blocks support."
+#endif // __BLOCKS__
+
+XPC_ASSUME_NONNULL_BEGIN
+__BEGIN_DECLS
+
+#pragma mark Constants
+/*!
+ * @typedef xpc_session_create_flags_t
+ * Constants representing different options available when creating an XPC
+ * Session.
+ *
+ * @const XPC_SESSION_CREATE_INACTIVE
+ * Indicates that the session should not be activated during its creation. The
+ * returned session must be manually activated using
+ * {@link xpc_session_activate} before it can be used.
+ *
+ * @const XPC_SESSION_CREATE_MACH_PRIVILEGED
+ * Passed to {@link xpc_session_create_mach_service} to indicate that the job
+ * advertising the service name in its launchd.plist(5) should be in the
+ * privileged Mach bootstrap. This is typically accomplished by placing your
+ * launchd.plist(5) in /Library/LaunchDaemons.
+ */
+XPC_FLAGS_ENUM(xpc_session_create_flags, uint64_t,
+	XPC_SESSION_CREATE_NONE XPC_SWIFT_NAME("none") = 0,
+	XPC_SESSION_CREATE_INACTIVE XPC_SWIFT_NAME("inactive") = (1 << 0),
+	XPC_SESSION_CREATE_MACH_PRIVILEGED XPC_SWIFT_NAME("privileged") = (1 << 1)
+);
+
+#pragma mark Handlers
+typedef void (^xpc_session_cancel_handler_t)(xpc_rich_error_t error);
+typedef void (^xpc_session_incoming_message_handler_t)(xpc_object_t message);
+typedef void (^xpc_session_reply_handler_t)(xpc_object_t _Nullable reply,
+		xpc_rich_error_t _Nullable error);
+
+#pragma mark Helpers
+/*!
+ * @function xpc_session_copy_description
+ * Copy the string description of the session.
+ *
+ * @param session
+ * The session to be examined.
+ *
+ * @result
+ * The underlying C string description for the provided session. This string
+ * should be disposed of with free(3) when done. This will return NULL if a
+ * string description could not be generated.
+ */
+API_AVAILABLE(macos(13.0), ios(16.0), tvos(16.0), watchos(9.0))
+XPC_EXPORT XPC_WARN_RESULT
+char * _Nullable
+xpc_session_copy_description(xpc_session_t session);
+
+#pragma mark Client Session Creation
+/*!
+ * @function xpc_session_create_xpc_service
+ * Creates a new session object representing a connection to the named service.
+ *
+ * @param name
+ * The name of the service to create a session with.
+ *
+ * @param target_queue
+ * The GCD queue onto which session events will be submitted. This may be a
+ * concurrent queue. This parameter may be NULL, in which case the target queue
+ * will be libdispatch's default target queue, defined as
+ * DISPATCH_TARGET_QUEUE_DEFAULT.
+ *
+ * @param flags
+ * Additional attributes which which to create the session.
+ *
+ * @param error_out
+ * An out-parameter that, if set and in the event of an error, will point to an
+ * {@link xpc_rich_error_t} describing the details of any errors that occurred.
+ *
+ * @result
+ * On success this returns a new session object. The returned session is
+ * activated by default and can be used to send messages. The caller is
+ * responsible for disposing of the returned object with {@link xpc_release}
+ * when it is no longer needed. On failure this will return NULL and if set,
+ * error_out will be set to an error describing the failure.
+ *
+ * @discussion
+ * This will fail if the specified XPC service is either not found or is
+ * unavailable.
+ */
+API_AVAILABLE(macos(13.0), ios(16.0), tvos(16.0), watchos(9.0))
+XPC_EXPORT XPC_RETURNS_RETAINED XPC_WARN_RESULT
+xpc_session_t _Nullable
+xpc_session_create_xpc_service(const char *name,
+		dispatch_queue_t _Nullable target_queue,
+		xpc_session_create_flags_t flags,
+		xpc_rich_error_t _Nullable * _Nullable error_out);
+
+/*!
+ * @function xpc_session_create_mach_service
+ * Creates a session with the service defined by the provided Mach service name.
+ *
+ * @param mach_service
+ * The Mach service to create a session with. The service name must exist in the
+ * Mach bootstrap that is accessible to the process and be advertised in a
+ * launchd.plist.
+ *
+ * @param target_queue
+ * The GCD queue onto which session events will be submitted. This may be a
+ * concurrent queue. This parameter may be NULL, in which case the target queue
+ * will be libdispatch's default target queue, defined as
+ * DISPATCH_TARGET_QUEUE_DEFAULT.
+ *
+ * @param flags
+ * Additional attributes which which to create the session.
+ *
+ * @param error_out
+ * An out-parameter that, if set and in the event of an error, will point to an
+ * {@link xpc_rich_error_t} describing the details of any errors that occurred.
+ *
+ * @param cancel_handler
+ * The cancel handler block that will be executed when this session is canceled.
+ *
+ * @result
+ * On success this returns a new session object. The returned session is
+ * activated by default and can be used to send messages. The caller is
+ * responsible for disposing of the returned object with {@link xpc_release}
+ * when it is no longer needed. On failure this will return NULL and if set,
+ * error_out will be set to an error describing the failure.
+ *
+ * @discussion
+ * This will fail if the specified Mach service is either not found in the
+ * bootstrap or is otherwise unavailable.
+ *
+ */
+API_AVAILABLE(macos(13.0), ios(16.0), tvos(16.0), watchos(9.0))
+XPC_EXPORT XPC_RETURNS_RETAINED XPC_WARN_RESULT
+xpc_session_t _Nullable
+xpc_session_create_mach_service(const char *mach_service,
+		dispatch_queue_t _Nullable target_queue,
+		xpc_session_create_flags_t flags,
+		xpc_rich_error_t _Nullable * _Nullable error_out);
+
+#pragma mark Session Configuration
+/*!
+ * @function xpc_session_set_incoming_message_handler
+ * Set an incoming message handler for a session.
+ *
+ * @param session
+ * The session to set the handler for.
+ *
+ * @param handler
+ * The handler block to be called when a message originated by the peer is
+ * received through the provided session.
+ *
+ * @discussion
+ * This can only be called on an inactive session. Calling this on a session
+ * with an existing event handler will replace it.
+ */
+API_AVAILABLE(macos(13.0), ios(16.0), tvos(16.0), watchos(9.0))
+XPC_EXPORT
+void
+xpc_session_set_incoming_message_handler(xpc_session_t session,
+		xpc_session_incoming_message_handler_t handler);
+
+/*!
+ * @function xpc_session_set_cancel_handler
+ * Set the cancel handler for a session.
+ *
+ * @param session
+ * The session to set the cancel handler for.
+ *
+ * @param cancel_handler
+ * The cancel handler block that will be executed when this session is canceled.
+ *
+ * @discussion
+ * This can only be called on an inactive session. Calling this on a session
+ * with an existing cancel handler will replace the existing cancel handler with
+ * the one provided.
+ */
+API_AVAILABLE(macos(13.0), ios(16.0), tvos(16.0), watchos(9.0))
+XPC_EXPORT
+void
+xpc_session_set_cancel_handler(xpc_session_t session,
+		xpc_session_cancel_handler_t cancel_handler);
+
+#pragma mark Lifecycle
+/*!
+ * @function xpc_session_activate
+ * Activates a session.
+ *
+ * @param session
+ * The session object to activate.
+ *
+ * @param error_out
+ * An out-parameter that, if set and in the event of an error, will point to an
+ * {@link xpc_rich_error_t} describing the details of any errors that occurred.
+ *
+ * @result
+ * Returns whether session activation succeeded.
+ *
+ * @discussion
+ * xpc_session_activate must not be called on a session that has been already
+ * activated. Releasing the last reference on an inactive session that was
+ * created with an xpc_session_create*() is undefined.
+ */
+API_AVAILABLE(macos(13.0), ios(16.0), tvos(16.0), watchos(9.0))
+XPC_EXPORT
+bool
+xpc_session_activate(xpc_session_t session,
+		xpc_rich_error_t _Nullable * _Nullable error_out);
+
+/*!
+ * @function xpc_session_cancel
+ * Cancels the session. After this call, any messages that have not yet been
+ * sent will be discarded, and the connection will be unwound. If there are
+ * messages that are awaiting replies, they will have their reply handlers
+ * invoked with an appropriate {@link xpc_rich_error_t}.
+ *
+ * @param session
+ * The session object to cancel.
+ *
+ * @discussion
+ * Session must have been activated to be canceled. Cancellation is asynchronous
+ * and non-preemptive.
+ */
+API_AVAILABLE(macos(13.0), ios(16.0), tvos(16.0), watchos(9.0))
+XPC_EXPORT
+void
+xpc_session_cancel(xpc_session_t session);
+
+#pragma mark Message Send
+/*!
+ * @function xpc_session_send_message
+ * Sends a message over the session to the destination service.
+ *
+ * @param session
+ * The session to send the message over.
+ *
+ * @param message
+ * The message to send. This must be a dictionary object.
+ *
+ * @result
+ * In the event of an error this will return an {@link xpc_rich_error_t}
+ * detailing the reasons for the failure. On success this return value will be
+ * NULL.
+ *
+ * @discussion
+ * Messages are delivered in FIFO order. This API is safe to call from multiple
+ * GCD queues. There is no indication that a message was delivered successfully.
+ * This is because even once the message has been successfully enqueued on the
+ * remote end, there are no guarantees about when the runtime will dequeue the
+ * message and invoke the other session's event handler block.
+ *
+ * If this is invoked on an inactive session, one created using the
+ * XPC_SESSION_CREATE_INACTIVE flag and hasn't yet been activated, the process
+ * will crash.
+ */
+API_AVAILABLE(macos(13.0), ios(16.0), tvos(16.0), watchos(9.0))
+XPC_EXPORT XPC_RETURNS_RETAINED XPC_WARN_RESULT
+xpc_rich_error_t _Nullable
+xpc_session_send_message(xpc_session_t session, xpc_object_t message);
+
+/*!
+ * @function xpc_session_send_message_with_reply_sync
+ * Sends a message over the session to the destination service and blocks the
+ * caller until a reply is received.
+ *
+ * @param session
+ * The session over which the message will be sent.
+ *
+ * @param message
+ * The message to send. This must be a dictionary object.
+ *
+ * @param error_out
+ * If this parameter is provided, in the event of a failure it will point to an
+ * {@link xpc_rich_error_t} describing the details of the error.
+ *
+ * @result
+ * On success, this will return the reply message as an {@link xpc_object_t}.
+ * Otherwise NULL is returned.
+ *
+ * @discussion
+ * This API supports priority inversion avoidance and should be used instead of
+ * combining xpc_session_send_message_with_reply_async with a semaphore.
+ *
+ * If this is invoked on an inactive session, for example one created using the
+ * XPC_SESSION_CREATE_INACTIVE flag that hasn't yet been activated, the process
+ * will crash.
+ * 
+ * Invoking this API while the target queue is blocked would lead to deadlocks
+ * in certain scenarios. For that reason, invoking it from the target queue
+ * results in a crash.
+ *
+ * Be judicious about your use of this API. It can block indefinitely, so if you
+ * are using it to implement an API that can be called from the main queue, you
+ * may wish to consider allowing the API to take a queue and callback block so
+ * that results may be delivered asynchronously if possible.
+ */
+API_AVAILABLE(macos(13.0), ios(16.0), tvos(16.0), watchos(9.0))
+XPC_EXPORT XPC_RETURNS_RETAINED XPC_WARN_RESULT
+xpc_object_t _Nullable
+xpc_session_send_message_with_reply_sync(xpc_session_t session,
+		xpc_object_t message, xpc_rich_error_t _Nullable * _Nullable error_out);
+
+/*!
+ * @function xpc_session_send_message_with_reply_async
+ * Sends a message over the session to the destination service and executes the
+ * provided callback when a reply is received.
+ *
+ * @param session
+ * The session over which the message will be sent.
+ *
+ * @param message
+ * The message to send. This must be a dictionary object.
+ *
+ * @param reply_handler
+ * The handler block to invoke when a reply to the message is received from the
+ * session. If the session is torn down before the reply was received, for
+ * example if the remote service exits prematurely, this handler will be
+ * executed and passed an appropriate {@link xpc_rich_error_t} object describing
+ * the failure.
+ *
+ * @discussion
+ * If this is invoked on an inactive session, for example one created using the
+ * XPC_SESSION_CREATE_INACTIVE flag that hasn't yet been activated, the process
+ * will crash.
+ *
+ * If this is invoked on a cancelled session, this will generate a simulated
+ * crash.
+ */
+API_AVAILABLE(macos(13.0), ios(16.0), tvos(16.0), watchos(9.0))
+XPC_EXPORT
+void
+xpc_session_send_message_with_reply_async(xpc_session_t session,
+		xpc_object_t message, xpc_session_reply_handler_t reply_handler);
+
+__END_DECLS
+XPC_ASSUME_NONNULL_END
+
+#endif // __XPC_SESSION_H__
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/xpc/xpc.h b/lib/libc/include/any-macos.13-any/xpc/xpc.h
similarity index 96%
rename from lib/libc/include/x86_64-macos.10-none/xpc/xpc.h
rename to lib/libc/include/any-macos.13-any/xpc/xpc.h
index cb6cbb3997..af3f49853e 100644
--- a/lib/libc/include/x86_64-macos.10-none/xpc/xpc.h
+++ b/lib/libc/include/any-macos.13-any/xpc/xpc.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2009-2011 Apple Inc. All rights reserved. 
+// Copyright (c) 2009-2020 Apple Inc. All rights reserved. 
 
 #ifndef __XPC_H__
 #define __XPC_H__
@@ -37,7 +37,7 @@ __BEGIN_DECLS
 #define __OSX_AVAILABLE_STARTING(x, y)
 #endif // __OSX_AVAILABLE_STARTING
 
-#define XPC_API_VERSION 20121012
+#define XPC_API_VERSION 20200610
 
 /*!
  * @typedef xpc_type_t
@@ -76,8 +76,7 @@ OS_OBJECT_DECL(xpc_object);
 XPC_INLINE XPC_NONNULL_ALL
 void
 _xpc_object_validate(xpc_object_t object) {
-	void *isa = *(void * volatile *)(OS_OBJECT_BRIDGE void *)object;
-	(void)isa;
+	(void)*(unsigned long volatile *)(OS_OBJECT_BRIDGE void *)object;
 }
 #else // OS_OBJECT_USE_OBJC
 typedef void * xpc_object_t;
@@ -211,7 +210,7 @@ XPC_TYPE(_xpc_type_double);
 
 /*!
  * @define XPC_TYPE_DATE
-* A type representing a date interval. The interval is with respect to the
+ * A type representing a date interval. The interval is with respect to the
  * Unix epoch. XPC dates are in Unix time and are thus unaware of local time
  * or leap seconds.
  */
@@ -326,13 +325,44 @@ __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
 XPC_EXPORT
 const char * const _xpc_event_key_name;
 
+/*!
+ * @define XPC_TYPE_SESSION
+ *
+ * @discussion
+ * Sessions represent a stateful connection between a client and a service. When either end of the connection
+ * disconnects, the entire session will be invalidated. In this case the system will make no attempt to
+ * reestablish the connection or relaunch the service.
+ *
+ * Clients can initiate a session with a service that accepts xpc_connection_t connections but session
+ * semantics will be maintained.
+ *
+ */
+#define XPC_TYPE_SESSION (&_xpc_type_session)
+XPC_EXPORT
+XPC_TYPE(_xpc_type_session);
+XPC_DECL(xpc_session);
+
+/*!
+ * @define XPC_TYPE_RICH_ERROR
+ *
+ * @discussion
+ * Rich errors provide a simple dynamic error type that can indicate whether an
+ * error is retry-able or not.
+ */
+#define XPC_TYPE_RICH_ERROR (&_xpc_type_rich_error)
+XPC_EXPORT
+XPC_TYPE(_xpc_type_rich_error);
+XPC_DECL(xpc_rich_error);
+
 XPC_ASSUME_NONNULL_END
 #if !defined(__XPC_BUILDING_XPC__) || !__XPC_BUILDING_XPC__
 #include <xpc/endpoint.h>
 #include <xpc/debug.h>
 #if __BLOCKS__
-#include <xpc/connection.h>
 #include <xpc/activity.h>
+#include <xpc/connection.h>
+#include <xpc/rich_error.h>
+#include <xpc/session.h>
 #endif // __BLOCKS__
 #undef __XPC_INDIRECT__
 #include <launch.h>
@@ -758,7 +788,7 @@ xpc_date_get_value(xpc_object_t xdate);
 __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
 XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
 xpc_object_t
-xpc_data_create(const void * _Nullable bytes, size_t length);
+xpc_data_create(const void * _Nullable XPC_SIZEDBY(length) bytes, size_t length);
 
 /*!
  * @function xpc_data_create_with_dispatch_data
@@ -1167,7 +1197,26 @@ typedef bool (^xpc_array_applier_t)(size_t index, xpc_object_t _Nonnull value);
 __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
 XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
 xpc_object_t
-xpc_array_create(const xpc_object_t _Nonnull * _Nullable objects, size_t count);
+xpc_array_create(
+	const xpc_object_t _Nonnull *XPC_COUNTEDBY(count) _Nullable objects,
+	size_t count);
+
+/*!
+ * @function xpc_array_create_empty
+ *
+ * @abstract
+ * Creates an XPC object representing an array of XPC objects.
+ *
+ * @result
+ * A new array object.
+ *
+ * @see
+ * xpc_array_create
+ */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
+xpc_object_t
+xpc_array_create_empty(void);
 
 /*!
  * @function xpc_array_set_value
@@ -1441,8 +1490,8 @@ xpc_array_set_date(xpc_object_t xarray, size_t index, int64_t value);
 __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
 XPC_EXPORT XPC_NONNULL1 XPC_NONNULL3
 void
-xpc_array_set_data(xpc_object_t xarray, size_t index, const void *bytes,
-	size_t length);
+xpc_array_set_data(xpc_object_t xarray, size_t index,
+	const void *XPC_SIZEDBY(length) bytes, size_t length);
 
 /*!
  * @function xpc_array_set_string
@@ -1895,8 +1944,27 @@ typedef bool (^xpc_dictionary_applier_t)(const char * _Nonnull key,
 __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
 XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
 xpc_object_t
-xpc_dictionary_create(const char * _Nonnull const * _Nullable keys,
-	const xpc_object_t _Nullable * _Nullable values, size_t count);
+xpc_dictionary_create(
+	const char *XPC_CSTRING _Nonnull const *XPC_COUNTEDBY(count) _Nullable keys,
+	const xpc_object_t _Nullable *XPC_COUNTEDBY(count) _Nullable values, size_t count);
+
+/*!
+ * @function xpc_dictionary_create_empty
+ *
+ * @abstract
+ * Creates an XPC object representing a dictionary of XPC objects keyed to
+ * C-strings.
+ *
+ * @result
+ * The new dictionary object.
+ *
+ * @see
+ * xpc_dictionary_create
+ */
+API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), watchos(7.0))
+XPC_EXPORT XPC_MALLOC XPC_RETURNS_RETAINED XPC_WARN_RESULT
+xpc_object_t
+xpc_dictionary_create_empty(void);
 
 /*!
  * @function xpc_dictionary_create_reply
@@ -2176,8 +2244,8 @@ xpc_dictionary_set_date(xpc_object_t xdict, const char *key, int64_t value);
 __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
 XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2 XPC_NONNULL3
 void
-xpc_dictionary_set_data(xpc_object_t xdict, const char *key, const void *bytes,
-	size_t length);
+xpc_dictionary_set_data(xpc_object_t xdict, const char *key,
+	const void *XPC_SIZEDBY(length) bytes, size_t length);
 
 /*!
  * @function xpc_dictionary_set_string
@@ -2589,7 +2657,7 @@ xpc_main(xpc_connection_handler_t handler);
  *
  * The XPC runtime will automatically begin a transaction on behalf of a service
  * when a new message is received. If no reply message is expected, the
- * transaction is automatically ended when the connection event handler returns.
+ * transaction is automatically ended when the last reference to the message is released.
  * If a reply message is created, the transaction will end when the reply
  * message is sent or released. An XPC service may use xpc_transaction_begin()
  * and xpc_transaction_end() to inform the XPC runtime about activity that
@@ -2648,6 +2716,10 @@ xpc_transaction_end(void);
  * @discussion
  * Multiple calls to this function for the same event stream will result in
  * undefined behavior.
+ *
+ * There is no API to pause delivery of XPC events. If a process that
+ * has set an XPC event handler exits, events may be dropped due to races
+ * between the event handler running and the process exiting.
  */
 #if __BLOCKS__
 __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0)
diff --git a/lib/libc/include/x86_64-macos.10-none/AssertMacros.h b/lib/libc/include/x86_64-macos.10-none/AssertMacros.h
deleted file mode 100644
index 7dc2e589af..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/AssertMacros.h
+++ /dev/null
@@ -1,1441 +0,0 @@
-/*
- * Copyright (c) 2002-2017 by Apple Inc.. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-
-/*
-	File:       AssertMacros.h
- 
-	Contains:   This file defines structured error handling and assertion macros for
-				programming in C. Originally used in QuickDraw GX and later enhanced.
-				These macros are used throughout Apple's software.
-	
-				New code may not want to begin adopting these macros and instead use
-				existing language functionality.
-	
-				See "Living In an Exceptional World" by Sean Parent
-				(develop, The Apple Technical Journal, Issue 11, August/September 1992)
-				<http://developer.apple.com/dev/techsupport/develop/issue11toc.shtml> or
-				<http://www.mactech.com/articles/develop/issue_11/Parent_final.html>
-				for the methodology behind these error handling and assertion macros.
-	
-	Bugs?:      For bug reports, consult the following page on
-				the World Wide Web:
-
-	 http://developer.apple.com/bugreporter/ 
-*/
-#ifndef __ASSERTMACROS__
-#define __ASSERTMACROS__
-
-#ifdef DEBUG_ASSERT_CONFIG_INCLUDE
-    #include DEBUG_ASSERT_CONFIG_INCLUDE
-#endif
-
-/*
- *  Macro overview:
- *  
- *      check(assertion)
- *         In production builds, pre-processed away  
- *         In debug builds, if assertion evaluates to false, calls DEBUG_ASSERT_MESSAGE
- *  
- *      verify(assertion)
- *         In production builds, evaluates assertion and does nothing
- *         In debug builds, if assertion evaluates to false, calls DEBUG_ASSERT_MESSAGE
- *  
- *      require(assertion, exceptionLabel)
- *         In production builds, if the assertion expression evaluates to false, goto exceptionLabel
- *         In debug builds, if the assertion expression evaluates to false, calls DEBUG_ASSERT_MESSAGE
- *                          and jumps to exceptionLabel
- *  
- *      In addition the following suffixes are available:
- * 
- *         _noerr     Adds "!= 0" to assertion.  Useful for asserting and OSStatus or OSErr is noErr (zero)
- *         _action    Adds statement to be executued if assertion fails
- *         _quiet     Suppress call to DEBUG_ASSERT_MESSAGE
- *         _string    Allows you to add explanitory message to DEBUG_ASSERT_MESSAGE
- *  
- *        For instance, require_noerr_string(resultCode, label, msg) will do nothing if 
- *        resultCode is zero, otherwise it will call DEBUG_ASSERT_MESSAGE with msg
- *        and jump to label.
- *
- *  Configuration:
- *
- *      By default all macros generate "production code" (i.e non-debug).  If  
- *      DEBUG_ASSERT_PRODUCTION_CODE is defined to zero or DEBUG is defined to non-zero
- *      while this header is included, the macros will generated debug code.
- *
- *      If DEBUG_ASSERT_COMPONENT_NAME_STRING is defined, all debug messages will
- *      be prefixed with it.
- *
- *      By default, all messages write to stderr.  If you would like to write a custom
- *      error message formater, defined DEBUG_ASSERT_MESSAGE to your function name.
- *
- *      Each individual macro will only be defined if it is not already defined, so
- *      you can redefine their behavior singly by providing your own definition before
- *      this file is included.
- *
- *      If you define __ASSERTMACROS__ before this file is included, then nothing in
- *      this file will take effect.
- *
- *      Prior to Mac OS X 10.6 the macro names used in this file conflicted with some
- *      user code, including libraries in boost and the proposed C++ standards efforts,
- *      and there was no way for a client of this header to resolve this conflict. Because
- *      of this, most of the macros have been changed so that they are prefixed with 
- *      __ and contain at least one capital letter, which should alleviate the current
- *      and future conflicts.  However, to allow current sources to continue to compile,
- *      compatibility macros are defined at the end with the old names.  A tops script 
- *      at the end of this file will convert all of the old macro names used in a directory
- *      to the new names.  Clients are recommended to migrate over to these new macros as
- *      they update their sources because a future release of Mac OS X will remove the
- *      old macro definitions ( without the double-underscore prefix ).  Clients who
- *      want to compile without the old macro definitions can define the macro
- *      __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES to 0 before this file is
- *      included.
- */
-
-
-/*
- *  Before including this file, #define DEBUG_ASSERT_COMPONENT_NAME_STRING to
- *  a C-string containing the name of your client. This string will be passed to
- *  the DEBUG_ASSERT_MESSAGE macro for inclusion in any assertion messages.
- *
- *  If you do not define DEBUG_ASSERT_COMPONENT_NAME_STRING, the default
- *  DEBUG_ASSERT_COMPONENT_NAME_STRING value, an empty string, will be used by
- *  the assertion macros.
- */
-#ifndef DEBUG_ASSERT_COMPONENT_NAME_STRING
-    #define DEBUG_ASSERT_COMPONENT_NAME_STRING ""
-#endif
-
-
-/*
- *  To activate the additional assertion code and messages for non-production builds,
- *  #define DEBUG_ASSERT_PRODUCTION_CODE to zero before including this file.
- *
- *  If you do not define DEBUG_ASSERT_PRODUCTION_CODE, the default value 1 will be used
- *  (production code = no assertion code and no messages).
- */
-#ifndef DEBUG_ASSERT_PRODUCTION_CODE
-   #define DEBUG_ASSERT_PRODUCTION_CODE !DEBUG
-#endif
-
-
-/*
- *  DEBUG_ASSERT_MESSAGE(component, assertion, label, error, file, line, errorCode)
- *
- *  Summary:
- *    All assertion messages are routed through this macro. If you wish to use your
- *    own routine to display assertion messages, you can override DEBUG_ASSERT_MESSAGE
- *    by #defining DEBUG_ASSERT_MESSAGE before including this file.
- *
- *  Parameters:
- *
- *    componentNameString:
- *      A pointer to a string constant containing the name of the
- *      component this code is part of. This must be a string constant
- *      (and not a string variable or NULL) because the preprocessor
- *      concatenates it with other string constants.
- *
- *    assertionString:
- *      A pointer to a string constant containing the assertion.
- *      This must be a string constant (and not a string variable or
- *      NULL) because the Preprocessor concatenates it with other
- *      string constants.
- *    
- *    exceptionLabelString:
- *      A pointer to a string containing the exceptionLabel, or NULL.
- *    
- *    errorString:
- *      A pointer to the error string, or NULL. DEBUG_ASSERT_MESSAGE macros
- *      must not attempt to concatenate this string with constant
- *      character strings.
- *    
- *    fileName:
- *      A pointer to the fileName or pathname (generated by the
- *      preprocessor __FILE__ identifier), or NULL.
- *    
- *    lineNumber:
- *      The line number in the file (generated by the preprocessor
- *      __LINE__ identifier), or 0 (zero).
- *    
- *    errorCode:
- *      A value associated with the assertion, or 0.
- *
- *  Here is an example of a DEBUG_ASSERT_MESSAGE macro and a routine which displays
- *  assertion messsages:
- *
- *      #define DEBUG_ASSERT_COMPONENT_NAME_STRING "MyCoolProgram"
- *
- *      #define DEBUG_ASSERT_MESSAGE(componentNameString, assertionString,                           \
- *                                   exceptionLabelString, errorString, fileName, lineNumber, errorCode) \
- *              MyProgramDebugAssert(componentNameString, assertionString,                           \
- *                                   exceptionLabelString, errorString, fileName, lineNumber, errorCode)
- *
- *      static void
- *      MyProgramDebugAssert(const char *componentNameString, const char *assertionString, 
- *                           const char *exceptionLabelString, const char *errorString, 
- *                           const char *fileName, long lineNumber, int errorCode)
- *      {
- *          if ( (assertionString != NULL) && (*assertionString != '\0') )
- *              fprintf(stderr, "Assertion failed: %s: %s\n", componentNameString, assertionString);
- *          else
- *              fprintf(stderr, "Check failed: %s:\n", componentNameString);
- *          if ( exceptionLabelString != NULL )
- *              fprintf(stderr, "    %s\n", exceptionLabelString);
- *          if ( errorString != NULL )
- *              fprintf(stderr, "    %s\n", errorString);
- *          if ( fileName != NULL )
- *              fprintf(stderr, "    file: %s\n", fileName);
- *          if ( lineNumber != 0 )
- *              fprintf(stderr, "    line: %ld\n", lineNumber);
- *          if ( errorCode != 0 )
- *              fprintf(stderr, "    error: %d\n", errorCode);
- *      }
- *
- *  If you do not define DEBUG_ASSERT_MESSAGE, a simple printf to stderr will be used.
- */
-#ifndef DEBUG_ASSERT_MESSAGE
-   #ifdef KERNEL
-      #include <libkern/libkern.h>
-      #define DEBUG_ASSERT_MESSAGE(name, assertion, label, message, file, line, value) \
-                                  printf( "AssertMacros: %s, %s file: %s, line: %d, value: %ld\n", assertion, (message!=0) ? message : "", file, line, (long) (value));
-   #else
-      #include <stdio.h>
-      #define DEBUG_ASSERT_MESSAGE(name, assertion, label, message, file, line, value) \
-                                  fprintf(stderr, "AssertMacros: %s, %s file: %s, line: %d, value: %ld\n", assertion, (message!=0) ? message : "", file, line, (long) (value));
-   #endif
-#endif
-
-
-
-
-
-/*
- *  __Debug_String(message)
- *
- *  Summary:
- *    Production builds: does nothing and produces no code.
- *
- *    Non-production builds: call DEBUG_ASSERT_MESSAGE.
- *
- *  Parameters:
- *
- *    message:
- *      The C string to display.
- *
- */
-#ifndef __Debug_String
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Debug_String(message)
-	#else
-	   #define __Debug_String(message)                                             \
-		  do                                                                      \
-		  {                                                                       \
-			  DEBUG_ASSERT_MESSAGE(                                               \
-				  DEBUG_ASSERT_COMPONENT_NAME_STRING,                             \
-				  "",                                                             \
-				  0,                                                              \
-				  message,                                                        \
-				  __FILE__,                                                       \
-				  __LINE__,                                                       \
-				  0);                                                             \
-		  } while ( 0 )
-	#endif
-#endif
-
-/*
- *  __Check(assertion)
- *
- *  Summary:
- *    Production builds: does nothing and produces no code.
- *
- *    Non-production builds: if the assertion expression evaluates to false,
- *    call DEBUG_ASSERT_MESSAGE.
- *
- *  Parameters:
- *
- *    assertion:
- *      The assertion expression.
- */
-#ifndef __Check
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Check(assertion)
-	#else
-	   #define __Check(assertion)                                                 \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(!(assertion), 0) )                            \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #assertion, 0, 0, __FILE__, __LINE__, 0 );                  \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-#ifndef __nCheck
-	#define __nCheck(assertion)  __Check(!(assertion))
-#endif
-
-/*
- *  __Check_String(assertion, message)
- *
- *  Summary:
- *    Production builds: does nothing and produces no code.
- *
- *    Non-production builds: if the assertion expression evaluates to false,
- *    call DEBUG_ASSERT_MESSAGE.
- *
- *  Parameters:
- *
- *    assertion:
- *      The assertion expression.
- *
- *    message:
- *      The C string to display.
- */
-#ifndef __Check_String
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Check_String(assertion, message)
-	#else
-	   #define __Check_String(assertion, message)                                 \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(!(assertion), 0) )                            \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #assertion, 0, message, __FILE__, __LINE__, 0 );            \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-#ifndef __nCheck_String
-	#define __nCheck_String(assertion, message)  __Check_String(!(assertion), message)
-#endif
-
-/*
- *  __Check_noErr(errorCode)
- *
- *  Summary:
- *    Production builds: does nothing and produces no code.
- *
- *    Non-production builds: if the errorCode expression does not equal 0 (noErr),
- *    call DEBUG_ASSERT_MESSAGE.
- *
- *  Parameters:
- *
- *    errorCode:
- *      The errorCode expression to compare with 0.
- */
-#ifndef __Check_noErr
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Check_noErr(errorCode)
-	#else
-	   #define __Check_noErr(errorCode)                                           \
-		  do                                                                      \
-		  {                                                                       \
-			  long evalOnceErrorCode = (errorCode);                               \
-			  if ( __builtin_expect(0 != evalOnceErrorCode, 0) )                  \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #errorCode " == 0 ", 0, 0, __FILE__, __LINE__, evalOnceErrorCode ); \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-/*
- *  __Check_noErr_String(errorCode, message)
- *
- *  Summary:
- *    Production builds: check_noerr_string() does nothing and produces
- *    no code.
- *
- *    Non-production builds: if the errorCode expression does not equal 0 (noErr),
- *    call DEBUG_ASSERT_MESSAGE.
- *
- *  Parameters:
- *
- *    errorCode:
- *      The errorCode expression to compare to 0.
- *
- *    message:
- *      The C string to display.
- */
-#ifndef __Check_noErr_String
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Check_noErr_String(errorCode, message)
-	#else
-	   #define __Check_noErr_String(errorCode, message)                           \
-		  do                                                                      \
-		  {                                                                       \
-			  long evalOnceErrorCode = (errorCode);                               \
-			  if ( __builtin_expect(0 != evalOnceErrorCode, 0) )                  \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #errorCode " == 0 ", 0, message, __FILE__, __LINE__, evalOnceErrorCode ); \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-/*
- *  __Verify(assertion)
- *
- *  Summary:
- *    Production builds: evaluate the assertion expression, but ignore
- *    the result.
- *
- *    Non-production builds: if the assertion expression evaluates to false,
- *    call DEBUG_ASSERT_MESSAGE.
- *
- *  Parameters:
- *
- *    assertion:
- *      The assertion expression.
- */
-#ifndef __Verify
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Verify(assertion)                                                \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( !(assertion) )                                                 \
-			  {                                                                   \
-			  }                                                                   \
-		  } while ( 0 )
-	#else
-	   #define __Verify(assertion)                                                \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(!(assertion), 0) )                            \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #assertion, 0, 0, __FILE__, __LINE__, 0 );                  \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-#ifndef __nVerify
-	#define __nVerify(assertion)	__Verify(!(assertion))
-#endif
-
-/*
- *  __Verify_String(assertion, message)
- *
- *  Summary:
- *    Production builds: evaluate the assertion expression, but ignore
- *    the result.
- *
- *    Non-production builds: if the assertion expression evaluates to false,
- *    call DEBUG_ASSERT_MESSAGE.
- *
- *  Parameters:
- *
- *    assertion:
- *      The assertion expression.
- *
- *    message:
- *      The C string to display.
- */
-#ifndef __Verify_String
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Verify_String(assertion, message)                                \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( !(assertion) )                                                 \
-			  {                                                                   \
-			  }                                                                   \
-		  } while ( 0 )
-	#else
-	   #define __Verify_String(assertion, message)                                \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(!(assertion), 0) )                            \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #assertion, 0, message, __FILE__, __LINE__, 0 );            \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-#ifndef __nVerify_String
-	#define __nVerify_String(assertion, message)  __Verify_String(!(assertion), message)
-#endif
-
-/*
- *  __Verify_noErr(errorCode)
- *
- *  Summary:
- *    Production builds: evaluate the errorCode expression, but ignore
- *    the result.
- *
- *    Non-production builds: if the errorCode expression does not equal 0 (noErr),
- *    call DEBUG_ASSERT_MESSAGE.
- *
- *  Parameters:
- *
- *    errorCode:
- *      The expression to compare to 0.
- */
-#ifndef __Verify_noErr
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Verify_noErr(errorCode)                                          \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( 0 != (errorCode) )                                             \
-			  {                                                                   \
-			  }                                                                   \
-		  } while ( 0 )
-	#else
-	   #define __Verify_noErr(errorCode)                                          \
-		  do                                                                      \
-		  {                                                                       \
-			  long evalOnceErrorCode = (errorCode);                               \
-			  if ( __builtin_expect(0 != evalOnceErrorCode, 0) )                  \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #errorCode " == 0 ", 0, 0, __FILE__, __LINE__, evalOnceErrorCode ); \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-/*
- *  __Verify_noErr_String(errorCode, message)
- *
- *  Summary:
- *    Production builds: evaluate the errorCode expression, but ignore
- *    the result.
- *
- *    Non-production builds: if the errorCode expression does not equal 0 (noErr),
- *    call DEBUG_ASSERT_MESSAGE.
- *
- *  Parameters:
- *
- *    errorCode:
- *      The expression to compare to 0.
- *
- *    message:
- *      The C string to display.
- */
-#ifndef __Verify_noErr_String
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Verify_noErr_String(errorCode, message)                          \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( 0 != (errorCode) )                                             \
-			  {                                                                   \
-			  }                                                                   \
-		  } while ( 0 )
-	#else
-	   #define __Verify_noErr_String(errorCode, message)                          \
-		  do                                                                      \
-		  {                                                                       \
-			  long evalOnceErrorCode = (errorCode);                               \
-			  if ( __builtin_expect(0 != evalOnceErrorCode, 0) )                  \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #errorCode " == 0 ", 0, message, __FILE__, __LINE__, evalOnceErrorCode ); \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-/*
- *  __Verify_noErr_Action(errorCode, action)
- *
- *  Summary:
- *    Production builds: if the errorCode expression does not equal 0 (noErr),
- *    execute the action statement or compound statement (block).
- *
- *    Non-production builds: if the errorCode expression does not equal 0 (noErr),
- *    call DEBUG_ASSERT_MESSAGE and then execute the action statement or compound
- *    statement (block).
- *
- *  Parameters:
- *
- *    errorCode:
- *      The expression to compare to 0.
- *
- *    action:
- *      The statement or compound statement (block).
- */
-#ifndef __Verify_noErr_Action
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Verify_noErr_Action(errorCode, action)                          \
-		  if ( 0 != (errorCode) ) {                                              \
-			  action;                                                            \
-		  }                                                                      \
-		  else do {} while (0)
-	#else
-	   #define __Verify_noErr_Action(errorCode, action)                          \
-               do {                                                                   \
-		  long evalOnceErrorCode = (errorCode);                                  \
-		  if ( __builtin_expect(0 != evalOnceErrorCode, 0) ) {                   \
-			  DEBUG_ASSERT_MESSAGE(                                              \
-				  DEBUG_ASSERT_COMPONENT_NAME_STRING,                            \
-				  #errorCode " == 0 ", 0, 0, __FILE__, __LINE__, evalOnceErrorCode );            \
-			  action;                                                            \
-		  }                                                                      \
-	       } while (0)
-	#endif
-#endif
-
-/*
- *  __Verify_Action(assertion, action)
- *
- *  Summary:
- *    Production builds: if the assertion expression evaluates to false,
- *    then execute the action statement or compound statement (block).
- *
- *    Non-production builds: if the assertion expression evaluates to false,
- *    call DEBUG_ASSERT_MESSAGE and then execute the action statement or compound
- *    statement (block).
- *
- *  Parameters:
- *
- *    assertion:
- *      The assertion expression.
- *
- *    action:
- *      The statement or compound statement (block).
- */
-#ifndef __Verify_Action
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Verify_Action(assertion, action)                                \
-		  if ( __builtin_expect(!(assertion), 0) ) {                             \
-			action;                                                              \
-		  }                                                                      \
-		  else do {} while (0)
-	#else
-	   #define __Verify_Action(assertion, action)                                \
-		  if ( __builtin_expect(!(assertion), 0) ) {                             \
-			  DEBUG_ASSERT_MESSAGE(                                              \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                        \
-					  #assertion, 0, 0, __FILE__, __LINE__, 0 );                 \
-			  action;                                                            \
-		  }                                                                      \
-		  else do {} while (0)
-	#endif
-#endif
-
-/*
- *  __Require(assertion, exceptionLabel)
- *
- *  Summary:
- *    Production builds: if the assertion expression evaluates to false,
- *    goto exceptionLabel.
- *
- *    Non-production builds: if the assertion expression evaluates to false,
- *    call DEBUG_ASSERT_MESSAGE and then goto exceptionLabel.
- *
- *  Parameters:
- *
- *    assertion:
- *      The assertion expression.
- *
- *    exceptionLabel:
- *      The label.
- */
-#ifndef __Require
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Require(assertion, exceptionLabel)                               \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(!(assertion), 0) )                            \
-			  {                                                                   \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#else
-	   #define __Require(assertion, exceptionLabel)                               \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(!(assertion), 0) ) {                          \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #assertion, #exceptionLabel, 0, __FILE__, __LINE__,  0);    \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-#ifndef __nRequire
-	#define __nRequire(assertion, exceptionLabel)  __Require(!(assertion), exceptionLabel)
-#endif
-
-/*
- *  __Require_Action(assertion, exceptionLabel, action)
- *
- *  Summary:
- *    Production builds: if the assertion expression evaluates to false,
- *    execute the action statement or compound statement (block) and then
- *    goto exceptionLabel.
- *
- *    Non-production builds: if the assertion expression evaluates to false,
- *    call DEBUG_ASSERT_MESSAGE, execute the action statement or compound
- *    statement (block), and then goto exceptionLabel.
- *
- *  Parameters:
- *
- *    assertion:
- *      The assertion expression.
- *
- *    exceptionLabel:
- *      The label.
- *
- *    action:
- *      The statement or compound statement (block).
- */
-#ifndef __Require_Action
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Require_Action(assertion, exceptionLabel, action)                \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(!(assertion), 0) )                            \
-			  {                                                                   \
-				  {                                                               \
-					  action;                                                     \
-				  }                                                               \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#else
-	   #define __Require_Action(assertion, exceptionLabel, action)                \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(!(assertion), 0) )                            \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #assertion, #exceptionLabel, 0,   __FILE__, __LINE__, 0);   \
-				  {                                                               \
-					  action;                                                     \
-				  }                                                               \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-#ifndef __nRequire_Action
-	#define __nRequire_Action(assertion, exceptionLabel, action)                  \
-	__Require_Action(!(assertion), exceptionLabel, action)
-#endif
-
-/*
- *  __Require_Quiet(assertion, exceptionLabel)
- *
- *  Summary:
- *    If the assertion expression evaluates to false, goto exceptionLabel.
- *
- *  Parameters:
- *
- *    assertion:
- *      The assertion expression.
- *
- *    exceptionLabel:
- *      The label.
- */
-#ifndef __Require_Quiet
-	#define __Require_Quiet(assertion, exceptionLabel)                            \
-	  do                                                                          \
-	  {                                                                           \
-		  if ( __builtin_expect(!(assertion), 0) )                                \
-		  {                                                                       \
-			  goto exceptionLabel;                                                \
-		  }                                                                       \
-	  } while ( 0 )
-#endif
-
-#ifndef __nRequire_Quiet
-	#define __nRequire_Quiet(assertion, exceptionLabel)  __Require_Quiet(!(assertion), exceptionLabel)
-#endif
-
-/*
- *  __Require_Action_Quiet(assertion, exceptionLabel, action)
- *
- *  Summary:
- *    If the assertion expression evaluates to false, execute the action
- *    statement or compound statement (block), and goto exceptionLabel.
- *
- *  Parameters:
- *
- *    assertion:
- *      The assertion expression.
- *
- *    exceptionLabel:
- *      The label.
- *
- *    action:
- *      The statement or compound statement (block).
- */
-#ifndef __Require_Action_Quiet
-	#define __Require_Action_Quiet(assertion, exceptionLabel, action)             \
-	  do                                                                          \
-	  {                                                                           \
-		  if ( __builtin_expect(!(assertion), 0) )                                \
-		  {                                                                       \
-			  {                                                                   \
-				  action;                                                         \
-			  }                                                                   \
-			  goto exceptionLabel;                                                \
-		  }                                                                       \
-	  } while ( 0 )
-#endif
-
-#ifndef __nRequire_Action_Quiet
-	#define __nRequire_Action_Quiet(assertion, exceptionLabel, action)              \
-		__Require_Action_Quiet(!(assertion), exceptionLabel, action)
-#endif
-
-/*
- *  __Require_String(assertion, exceptionLabel, message)
- *
- *  Summary:
- *    Production builds: if the assertion expression evaluates to false,
- *    goto exceptionLabel.
- *
- *    Non-production builds: if the assertion expression evaluates to false,
- *    call DEBUG_ASSERT_MESSAGE, and then goto exceptionLabel.
- *
- *  Parameters:
- *
- *    assertion:
- *      The assertion expression.
- *
- *    exceptionLabel:
- *      The label.
- *
- *    message:
- *      The C string to display.
- */
-#ifndef __Require_String
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Require_String(assertion, exceptionLabel, message)               \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(!(assertion), 0) )                            \
-			  {                                                                   \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#else
-	   #define __Require_String(assertion, exceptionLabel, message)               \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(!(assertion), 0) )                            \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #assertion, #exceptionLabel,  message,  __FILE__, __LINE__, 0); \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-#ifndef __nRequire_String
-	#define __nRequire_String(assertion, exceptionLabel, string)                  \
-		__Require_String(!(assertion), exceptionLabel, string)
-#endif
-
-/*
- *  __Require_Action_String(assertion, exceptionLabel, action, message)
- *
- *  Summary:
- *    Production builds: if the assertion expression evaluates to false,
- *    execute the action statement or compound statement (block), and then
- *    goto exceptionLabel.
- *
- *    Non-production builds: if the assertion expression evaluates to false,
- *    call DEBUG_ASSERT_MESSAGE, execute the action statement or compound
- *    statement (block), and then goto exceptionLabel.
- *
- *  Parameters:
- *
- *    assertion:
- *      The assertion expression.
- *
- *    exceptionLabel:
- *      The label.
- *
- *    action:
- *      The statement or compound statement (block).
- *
- *    message:
- *      The C string to display.
- */
-#ifndef __Require_Action_String
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Require_Action_String(assertion, exceptionLabel, action, message)  \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(!(assertion), 0) )                            \
-			  {                                                                   \
-				  {                                                               \
-					  action;                                                     \
-				  }                                                               \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#else
-	   #define __Require_Action_String(assertion, exceptionLabel, action, message)  \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(!(assertion), 0) )                            \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #assertion, #exceptionLabel,  message,  __FILE__,  __LINE__, 0); \
-				  {                                                               \
-					  action;                                                     \
-				  }                                                               \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-#ifndef __nRequire_Action_String
-	#define __nRequire_Action_String(assertion, exceptionLabel, action, message)    \
-		__Require_Action_String(!(assertion), exceptionLabel, action, message)
-#endif
-
-/*
- *  __Require_noErr(errorCode, exceptionLabel)
- *
- *  Summary:
- *    Production builds: if the errorCode expression does not equal 0 (noErr),
- *    goto exceptionLabel.
- *
- *    Non-production builds: if the errorCode expression does not equal 0 (noErr),
- *    call DEBUG_ASSERT_MESSAGE and then goto exceptionLabel.
- *
- *  Parameters:
- *
- *    errorCode:
- *      The expression to compare to 0.
- *
- *    exceptionLabel:
- *      The label.
- */
-#ifndef __Require_noErr
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Require_noErr(errorCode, exceptionLabel)                         \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(0 != (errorCode), 0) )                        \
-			  {                                                                   \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#else
-	   #define __Require_noErr(errorCode, exceptionLabel)                         \
-		  do                                                                      \
-		  {                                                                       \
-			  long evalOnceErrorCode = (errorCode);                               \
-			  if ( __builtin_expect(0 != evalOnceErrorCode, 0) )                  \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #errorCode " == 0 ",  #exceptionLabel,  0,  __FILE__, __LINE__, evalOnceErrorCode); \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-/*
- *  __Require_noErr_Action(errorCode, exceptionLabel, action)
- *
- *  Summary:
- *    Production builds: if the errorCode expression does not equal 0 (noErr),
- *    execute the action statement or compound statement (block) and
- *    goto exceptionLabel.
- *
- *    Non-production builds: if the errorCode expression does not equal 0 (noErr),
- *    call DEBUG_ASSERT_MESSAGE, execute the action statement or
- *    compound statement (block), and then goto exceptionLabel.
- *
- *  Parameters:
- *
- *    errorCode:
- *      The expression to compare to 0.
- *
- *    exceptionLabel:
- *      The label.
- *
- *    action:
- *      The statement or compound statement (block).
- */
-#ifndef __Require_noErr_Action
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Require_noErr_Action(errorCode, exceptionLabel, action)          \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(0 != (errorCode), 0) )                        \
-			  {                                                                   \
-				  {                                                               \
-					  action;                                                     \
-				  }                                                               \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#else
-	   #define __Require_noErr_Action(errorCode, exceptionLabel, action)          \
-		  do                                                                      \
-		  {                                                                       \
-			  long evalOnceErrorCode = (errorCode);                               \
-			  if ( __builtin_expect(0 != evalOnceErrorCode, 0) )                  \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #errorCode " == 0 ", #exceptionLabel,  0,  __FILE__, __LINE__,  evalOnceErrorCode); \
-				  {                                                               \
-					  action;                                                     \
-				  }                                                               \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-/*
- *  __Require_noErr_Quiet(errorCode, exceptionLabel)
- *
- *  Summary:
- *    If the errorCode expression does not equal 0 (noErr),
- *    goto exceptionLabel.
- *
- *  Parameters:
- *
- *    errorCode:
- *      The expression to compare to 0.
- *
- *    exceptionLabel:
- *      The label.
- */
-#ifndef __Require_noErr_Quiet
-	#define __Require_noErr_Quiet(errorCode, exceptionLabel)                      \
-	  do                                                                          \
-	  {                                                                           \
-		  if ( __builtin_expect(0 != (errorCode), 0) )                            \
-		  {                                                                       \
-			  goto exceptionLabel;                                                \
-		  }                                                                       \
-	  } while ( 0 )
-#endif
-
-/*
- *  __Require_noErr_Action_Quiet(errorCode, exceptionLabel, action)
- *
- *  Summary:
- *    If the errorCode expression does not equal 0 (noErr),
- *    execute the action statement or compound statement (block) and
- *    goto exceptionLabel.
- *
- *  Parameters:
- *
- *    errorCode:
- *      The expression to compare to 0.
- *
- *    exceptionLabel:
- *      The label.
- *
- *    action:
- *      The statement or compound statement (block).
- */
-#ifndef __Require_noErr_Action_Quiet
-	#define __Require_noErr_Action_Quiet(errorCode, exceptionLabel, action)       \
-	  do                                                                          \
-	  {                                                                           \
-		  if ( __builtin_expect(0 != (errorCode), 0) )                            \
-		  {                                                                       \
-			  {                                                                   \
-				  action;                                                         \
-			  }                                                                   \
-			  goto exceptionLabel;                                                \
-		  }                                                                       \
-	  } while ( 0 )
-#endif
-
-/*
- *  __Require_noErr_String(errorCode, exceptionLabel, message)
- *
- *  Summary:
- *    Production builds: if the errorCode expression does not equal 0 (noErr),
- *    goto exceptionLabel.
- *
- *    Non-production builds: if the errorCode expression does not equal 0 (noErr),
- *    call DEBUG_ASSERT_MESSAGE, and then goto exceptionLabel.
- *
- *  Parameters:
- *
- *    errorCode:
- *      The expression to compare to 0.
- *
- *    exceptionLabel:
- *      The label.
- *
- *    message:
- *      The C string to display.
- */
-#ifndef __Require_noErr_String
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Require_noErr_String(errorCode, exceptionLabel, message)         \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(0 != (errorCode), 0) )                        \
-			  {                                                                   \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#else
-	   #define __Require_noErr_String(errorCode, exceptionLabel, message)         \
-		  do                                                                      \
-		  {                                                                       \
-			  long evalOnceErrorCode = (errorCode);                               \
-			  if ( __builtin_expect(0 != evalOnceErrorCode, 0) )                  \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #errorCode " == 0 ",  #exceptionLabel, message, __FILE__,  __LINE__,  evalOnceErrorCode); \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-/*
- *  __Require_noErr_Action_String(errorCode, exceptionLabel, action, message)
- *
- *  Summary:
- *    Production builds: if the errorCode expression does not equal 0 (noErr),
- *    execute the action statement or compound statement (block) and
- *    goto exceptionLabel.
- *
- *    Non-production builds: if the errorCode expression does not equal 0 (noErr),
- *    call DEBUG_ASSERT_MESSAGE, execute the action statement or compound
- *    statement (block), and then goto exceptionLabel.
- *
- *  Parameters:
- *
- *    errorCode:
- *      The expression to compare to 0.
- *
- *    exceptionLabel:
- *      The label.
- *
- *    action:
- *      The statement or compound statement (block).
- *
- *    message:
- *      The C string to display.
- */
-#ifndef __Require_noErr_Action_String
-	#if DEBUG_ASSERT_PRODUCTION_CODE
-	   #define __Require_noErr_Action_String(errorCode, exceptionLabel, action, message) \
-		  do                                                                      \
-		  {                                                                       \
-			  if ( __builtin_expect(0 != (errorCode), 0) )                        \
-			  {                                                                   \
-				  {                                                               \
-					  action;                                                     \
-				  }                                                               \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#else
-	   #define __Require_noErr_Action_String(errorCode, exceptionLabel, action, message) \
-		  do                                                                      \
-		  {                                                                       \
-			  long evalOnceErrorCode = (errorCode);                               \
-			  if ( __builtin_expect(0 != evalOnceErrorCode, 0) )                  \
-			  {                                                                   \
-				  DEBUG_ASSERT_MESSAGE(                                           \
-					  DEBUG_ASSERT_COMPONENT_NAME_STRING,                         \
-					  #errorCode " == 0 ", #exceptionLabel, message, __FILE__, __LINE__, evalOnceErrorCode); \
-				  {                                                               \
-					  action;                                                     \
-				  }                                                               \
-				  goto exceptionLabel;                                            \
-			  }                                                                   \
-		  } while ( 0 )
-	#endif
-#endif
-
-/*
- *  __Check_Compile_Time(expr)
- *
- *  Summary:
- *    any build: if the expression is not true, generated a compile time error.
- *
- *  Parameters:
- *
- *    expr:
- *      The compile time expression that should evaluate to non-zero.
- *
- *  Discussion:
- *     This declares an array with a size that is determined by a compile-time expression.
- *     If false, it declares a negatively sized array, which generates a compile-time error.
- *
- * Examples:
- *     __Check_Compile_Time( sizeof( int ) == 4 );
- *     __Check_Compile_Time( offsetof( MyStruct, myField ) == 4 );
- *     __Check_Compile_Time( ( kMyBufferSize % 512 ) == 0 );
- *
- *  Note: This only works with compile-time expressions.
- *  Note: This only works in places where extern declarations are allowed (e.g. global scope).
- */
-#ifndef __Check_Compile_Time
-    #ifdef __GNUC__ 
-     #if (__cplusplus >= 201103L)
-        #define __Check_Compile_Time( expr )    static_assert( expr , "__Check_Compile_Time")        
-     #elif (__STDC_VERSION__ >= 201112L)
-        #define __Check_Compile_Time( expr )    _Static_assert( expr , "__Check_Compile_Time")
-     #else
-        #define __Check_Compile_Time( expr )    \
-            extern int compile_time_assert_failed[ ( expr ) ? 1 : -1 ] __attribute__( ( unused ) )
-     #endif
-    #else
-        #define __Check_Compile_Time( expr )    \
-            extern int compile_time_assert_failed[ ( expr ) ? 1 : -1 ]
-    #endif
-#endif
-
-/*
- *	For time immemorial, Mac OS X has defined version of most of these macros without the __ prefix, which
- *	could collide with similarly named functions or macros in user code, including new functionality in
- *	Boost and the C++ standard library.
- *
- *  macOS High Sierra and iOS 11 will now require that clients move to the new macros as defined above.
- *
- *  If you would like to enable the macros for use within your own project, you can define the
- *  __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES macro via an Xcode Build Configuration.
- *  See "Add a build configuration (xcconfig) file" in Xcode Help. 
- *
- *  To aid users of these macros in converting their sources, the following tops script will convert usages
- *  of the old macros into the new equivalents.  To do so, in Terminal go into the directory containing the
- *  sources to be converted and run this command.
- *
-    find -E . -regex '.*\.(c|cc|cp|cpp|m|mm|h)' -print0 |  xargs -0 tops -verbose \
-      replace "check(<b args>)" with "__Check(<args>)" \
-      replace "check_noerr(<b args>)" with "__Check_noErr(<args>)" \
-      replace "check_noerr_string(<b args>)" with "__Check_noErr_String(<args>)" \
-      replace "check_string(<b args>)" with "__Check_String(<args>)" \
-      replace "require(<b args>)" with "__Require(<args>)" \
-      replace "require_action(<b args>)" with "__Require_Action(<args>)" \
-      replace "require_action_string(<b args>)" with "__Require_Action_String(<args>)" \
-      replace "require_noerr(<b args>)" with "__Require_noErr(<args>)" \
-      replace "require_noerr_action(<b args>)" with "__Require_noErr_Action(<args>)" \
-      replace "require_noerr_action_string(<b args>)" with "__Require_noErr_Action_String(<args>)" \
-      replace "require_noerr_string(<b args>)" with "__Require_noErr_String(<args>)" \
-      replace "require_string(<b args>)" with "__Require_String(<args>)" \
-      replace "verify(<b args>)" with "__Verify(<args>)" \
-      replace "verify_action(<b args>)" with "__Verify_Action(<args>)" \
-      replace "verify_noerr(<b args>)" with "__Verify_noErr(<args>)" \
-      replace "verify_noerr_action(<b args>)" with "__Verify_noErr_Action(<args>)" \
-      replace "verify_noerr_string(<b args>)" with "__Verify_noErr_String(<args>)" \
-      replace "verify_string(<b args>)" with "__Verify_String(<args>)" \
-      replace "ncheck(<b args>)" with "__nCheck(<args>)" \
-      replace "ncheck_string(<b args>)" with "__nCheck_String(<args>)" \
-      replace "nrequire(<b args>)" with "__nRequire(<args>)" \
-      replace "nrequire_action(<b args>)" with "__nRequire_Action(<args>)" \
-      replace "nrequire_action_quiet(<b args>)" with "__nRequire_Action_Quiet(<args>)" \
-      replace "nrequire_action_string(<b args>)" with "__nRequire_Action_String(<args>)" \
-      replace "nrequire_quiet(<b args>)" with "__nRequire_Quiet(<args>)" \
-      replace "nrequire_string(<b args>)" with "__nRequire_String(<args>)" \
-      replace "nverify(<b args>)" with "__nVerify(<args>)" \
-      replace "nverify_string(<b args>)" with "__nVerify_String(<args>)" \
-      replace "require_action_quiet(<b args>)" with "__Require_Action_Quiet(<args>)" \
-      replace "require_noerr_action_quiet(<b args>)" with "__Require_noErr_Action_Quiet(<args>)" \
-      replace "require_noerr_quiet(<b args>)" with "__Require_noErr_Quiet(<args>)" \
-      replace "require_quiet(<b args>)" with "__Require_Quiet(<args>)" \
-      replace "check_compile_time(<b args>)" with "__Check_Compile_Time(<args>)" \
-      replace "debug_string(<b args>)" with "__Debug_String(<args>)"
- *
- */
-
-#ifndef __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES
-    #if __has_include(<AssertMacrosInternal.h>)
-        #include <AssertMacrosInternal.h>
-    #else 
-        /* In  macOS High Sierra and iOS 11, if we haven't set this yet, it now defaults to off. */
-        #define	__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES	0
-    #endif
-#endif
-
-#if	__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES
-
-	#ifndef check
-	#define check(assertion)  __Check(assertion)
-	#endif
-
-	#ifndef check_noerr
-	#define check_noerr(errorCode)  __Check_noErr(errorCode)
-	#endif
-
-	#ifndef check_noerr_string
-		#define check_noerr_string(errorCode, message)  __Check_noErr_String(errorCode, message)
-	#endif
-
-	#ifndef check_string
-		#define check_string(assertion, message)  __Check_String(assertion, message)
-	#endif
-
-	#ifndef require
-		#define require(assertion, exceptionLabel)  __Require(assertion, exceptionLabel)
-	#endif
-
-	#ifndef require_action
-		#define require_action(assertion, exceptionLabel, action)  __Require_Action(assertion, exceptionLabel, action)
-	#endif
-
-	#ifndef require_action_string
-		#define require_action_string(assertion, exceptionLabel, action, message)  __Require_Action_String(assertion, exceptionLabel, action, message)
-	#endif
-
-	#ifndef require_noerr
-		#define require_noerr(errorCode, exceptionLabel)  __Require_noErr(errorCode, exceptionLabel)
-	#endif
-
-	#ifndef require_noerr_action
-		#define require_noerr_action(errorCode, exceptionLabel, action)  __Require_noErr_Action(errorCode, exceptionLabel, action)
-	#endif
-
-	#ifndef require_noerr_action_string
-		#define require_noerr_action_string(errorCode, exceptionLabel, action, message)  __Require_noErr_Action_String(errorCode, exceptionLabel, action, message)
-	#endif
-
-	#ifndef require_noerr_string
-		#define require_noerr_string(errorCode, exceptionLabel, message)  __Require_noErr_String(errorCode, exceptionLabel, message)
-	#endif
-
-	#ifndef require_string
-		#define require_string(assertion, exceptionLabel, message)  __Require_String(assertion, exceptionLabel, message)
-	#endif
-
-	#ifndef verify
-		#define verify(assertion) __Verify(assertion)
-	#endif
-
-	#ifndef verify_action
-		#define verify_action(assertion, action)  __Verify_Action(assertion, action)
-	#endif
-
-	#ifndef verify_noerr
-		#define verify_noerr(errorCode)  __Verify_noErr(errorCode)
-	#endif
-
-	#ifndef verify_noerr_action
-		#define verify_noerr_action(errorCode, action)  __Verify_noErr_Action(errorCode, action)
-	#endif
-
-	#ifndef verify_noerr_string
-		#define verify_noerr_string(errorCode, message)  __Verify_noErr_String(errorCode, message)
-	#endif
-
-	#ifndef verify_string
-		#define verify_string(assertion, message)  __Verify_String(assertion, message)
-	#endif
-
-	#ifndef ncheck
-		#define ncheck(assertion)  __nCheck(assertion)
-	#endif
-
-	#ifndef ncheck_string
-		#define ncheck_string(assertion, message)  __nCheck_String(assertion, message)
-	#endif
-
-	#ifndef nrequire
-		#define nrequire(assertion, exceptionLabel)  __nRequire(assertion, exceptionLabel)
-	#endif
-
-	#ifndef nrequire_action
-		#define nrequire_action(assertion, exceptionLabel, action)  __nRequire_Action(assertion, exceptionLabel, action)
-	#endif
-
-	#ifndef nrequire_action_quiet
-		#define nrequire_action_quiet(assertion, exceptionLabel, action)  __nRequire_Action_Quiet(assertion, exceptionLabel, action)
-	#endif
-
-	#ifndef nrequire_action_string
-		#define nrequire_action_string(assertion, exceptionLabel, action, message)  __nRequire_Action_String(assertion, exceptionLabel, action, message)
-	#endif
-
-	#ifndef nrequire_quiet
-		#define nrequire_quiet(assertion, exceptionLabel)  __nRequire_Quiet(assertion, exceptionLabel)
-	#endif
-
-	#ifndef nrequire_string
-		#define nrequire_string(assertion, exceptionLabel, string)  __nRequire_String(assertion, exceptionLabel, string)
-	#endif
-
-	#ifndef nverify
-		#define nverify(assertion)  __nVerify(assertion)
-	#endif
-
-	#ifndef nverify_string
-		#define nverify_string(assertion, message)  __nVerify_String(assertion, message)
-	#endif
-
-	#ifndef require_action_quiet
-		#define require_action_quiet(assertion, exceptionLabel, action)  __Require_Action_Quiet(assertion, exceptionLabel, action)
-	#endif
-
-	#ifndef require_noerr_action_quiet
-		#define require_noerr_action_quiet(errorCode, exceptionLabel, action)  __Require_noErr_Action_Quiet(errorCode, exceptionLabel, action)
-	#endif
-
-	#ifndef require_noerr_quiet
-		#define require_noerr_quiet(errorCode, exceptionLabel)  __Require_noErr_Quiet(errorCode, exceptionLabel)
-	#endif
-
-	#ifndef require_quiet
-		#define require_quiet(assertion, exceptionLabel)  __Require_Quiet(assertion, exceptionLabel)
-	#endif
-
-	#ifndef check_compile_time
-		#define check_compile_time( expr )  __Check_Compile_Time( expr )
-	#endif
-
-	#ifndef debug_string
-		#define debug_string(message)  __Debug_String(message)
-	#endif
-	
-#endif	/* ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES */
-
-
-#endif /* __ASSERTMACROS__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/TargetConditionals.h b/lib/libc/include/x86_64-macos.10-none/TargetConditionals.h
deleted file mode 100644
index 896956f33d..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/TargetConditionals.h
+++ /dev/null
@@ -1,502 +0,0 @@
-/*
- * Copyright (c) 2000-2014 by Apple Inc.. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
- 
-/*
-     File:       TargetConditionals.h
- 
-     Contains:   Autoconfiguration of TARGET_ conditionals for Mac OS X and iPhone
-     
-                 Note:  TargetConditionals.h in 3.4 Universal Interfaces works
-                        with all compilers.  This header only recognizes compilers
-                        known to run on Mac OS X.
-  
-*/
-
-#ifndef __TARGETCONDITIONALS__
-#define __TARGETCONDITIONALS__
-
-/****************************************************************************************************
-
-    TARGET_CPU_*    
-    These conditionals specify which microprocessor instruction set is being
-    generated.  At most one of these is true, the rest are false.
-
-        TARGET_CPU_PPC          - Compiler is generating PowerPC instructions for 32-bit mode
-        TARGET_CPU_PPC64        - Compiler is generating PowerPC instructions for 64-bit mode
-        TARGET_CPU_68K          - Compiler is generating 680x0 instructions
-        TARGET_CPU_X86          - Compiler is generating x86 instructions for 32-bit mode
-        TARGET_CPU_X86_64       - Compiler is generating x86 instructions for 64-bit mode
-        TARGET_CPU_ARM          - Compiler is generating ARM instructions for 32-bit mode
-        TARGET_CPU_ARM64        - Compiler is generating ARM instructions for 64-bit mode
-        TARGET_CPU_MIPS         - Compiler is generating MIPS instructions
-        TARGET_CPU_SPARC        - Compiler is generating Sparc instructions
-        TARGET_CPU_ALPHA        - Compiler is generating Dec Alpha instructions
-
-
-    TARGET_OS_* 
-    These conditionals specify in which Operating System the generated code will
-    run.  Indention is used to show which conditionals are evolutionary subclasses.  
-    
-    The MAC/WIN32/UNIX conditionals are mutually exclusive.
-    The IOS/TV/WATCH conditionals are mutually exclusive.
-    
-    
-        TARGET_OS_WIN32           - Generated code will run under 32-bit Windows
-        TARGET_OS_UNIX            - Generated code will run under some Unix (not OSX) 
-        TARGET_OS_MAC             - Generated code will run under Mac OS X variant
-           TARGET_OS_OSX          - Generated code will run under OS X devices
-           TARGET_OS_IPHONE          - Generated code for firmware, devices, or simulator
-              TARGET_OS_IOS             - Generated code will run under iOS 
-              TARGET_OS_TV              - Generated code will run under Apple TV OS
-              TARGET_OS_WATCH           - Generated code will run under Apple Watch OS
-              TARGET_OS_BRIDGE          - Generated code will run under Bridge devices
-              TARGET_OS_MACCATALYST     - Generated code will run under macOS
-           TARGET_OS_SIMULATOR      - Generated code will run under a simulator
-       
-        TARGET_OS_EMBEDDED        - DEPRECATED: Use TARGET_OS_IPHONE and/or TARGET_OS_SIMULATOR instead
-        TARGET_IPHONE_SIMULATOR   - DEPRECATED: Same as TARGET_OS_SIMULATOR
-        TARGET_OS_NANO            - DEPRECATED: Same as TARGET_OS_WATCH
-
-      +----------------------------------------------------------------+
-      |                TARGET_OS_MAC                                   |
-      | +---+  +-----------------------------------------------------+ |
-      | |   |  |          TARGET_OS_IPHONE                           | |
-      | |OSX|  | +-----+ +----+ +-------+ +--------+ +-------------+ | |
-      | |   |  | | IOS | | TV | | WATCH | | BRIDGE | | MACCATALYST | | |
-      | |   |  | +-----+ +----+ +-------+ +--------+ +-------------+ | |
-      | +---+  +-----------------------------------------------------+ |
-      +----------------------------------------------------------------+
-
-    TARGET_RT_* 
-    These conditionals specify in which runtime the generated code will
-    run. This is needed when the OS and CPU support more than one runtime
-    (e.g. Mac OS X supports CFM and mach-o).
-
-        TARGET_RT_LITTLE_ENDIAN - Generated code uses little endian format for integers
-        TARGET_RT_BIG_ENDIAN    - Generated code uses big endian format for integers    
-        TARGET_RT_64_BIT        - Generated code uses 64-bit pointers    
-        TARGET_RT_MAC_CFM       - TARGET_OS_MAC is true and CFM68K or PowerPC CFM (TVectors) are used
-        TARGET_RT_MAC_MACHO     - TARGET_OS_MAC is true and Mach-O/dlyd runtime is used
-        
-
-****************************************************************************************************/
- 
- /*
- * TARGET_OS conditionals can be enabled via clang preprocessor extensions:
- *
- *      __is_target_arch
- *      __is_target_vendor
- *      __is_target_os
- *      __is_target_environment
- *
- *  “-target=x86_64-apple-ios12-macabi”
- *      TARGET_OS_MAC=1
- *      TARGET_OS_IPHONE=1
- *      TARGET_OS_IOS=1
- *      TARGET_OS_MACCATALYST=1
- *
- *  “-target=x86_64-apple-ios12-simulator”
- *      TARGET_OS_MAC=1
- *      TARGET_OS_IPHONE=1
- *      TARGET_OS_IOS=1
- *      TARGET_OS_SIMULATOR=1
- *
- * DYNAMIC_TARGETS_ENABLED indicates that the core TARGET_OS macros were enabled via clang preprocessor extensions.
- * If this value is not set, the macro enablements will fall back to the static behavior.
- * It is disabled by default.
- */
-
-#if defined(__has_builtin)
- #if __has_builtin(__is_target_arch)
-  #if __has_builtin(__is_target_vendor)
-   #if __has_builtin(__is_target_os)
-    #if __has_builtin(__is_target_environment)
-
-    /* “-target=x86_64-apple-ios12-macabi” */
-    #if __is_target_arch(x86_64) && __is_target_vendor(apple) && __is_target_os(ios) && __is_target_environment(macabi)
-        #define TARGET_OS_OSX               0
-        #define TARGET_OS_IPHONE            1
-        #define TARGET_OS_IOS               1
-        #define TARGET_OS_WATCH             0
-        
-        #define TARGET_OS_TV                0
-        #define TARGET_OS_SIMULATOR         0
-        #define TARGET_OS_EMBEDDED          0    
-        #define TARGET_OS_RTKIT             0
-        #define TARGET_OS_MACCATALYST       1
-        #define TARGET_OS_MACCATALYST            1
-        #ifndef TARGET_OS_UIKITFORMAC
-         #define TARGET_OS_UIKITFORMAC      1
-        #endif
-        #define TARGET_OS_DRIVERKIT         0
-        #define DYNAMIC_TARGETS_ENABLED     1
-    #endif 
-
-    /* “-target=x86_64-apple-ios12-simulator” */
-    #if __is_target_arch(x86_64) && __is_target_vendor(apple) && __is_target_os(ios) && __is_target_environment(simulator)
-        #define TARGET_OS_OSX               0
-        #define TARGET_OS_IPHONE            1
-        #define TARGET_OS_IOS               1
-        #define TARGET_OS_WATCH             0
-        
-        #define TARGET_OS_TV                0
-        #define TARGET_OS_SIMULATOR         1
-        #define TARGET_OS_EMBEDDED          0    
-        #define TARGET_OS_RTKIT             0
-        #define TARGET_OS_MACCATALYST       0
-        #define TARGET_OS_MACCATALYST            0
-        #ifndef TARGET_OS_UIKITFORMAC
-         #define TARGET_OS_UIKITFORMAC      0
-        #endif
-        #define TARGET_OS_DRIVERKIT         0
-        #define DYNAMIC_TARGETS_ENABLED     1
-    #endif 
-
-    /* -target=x86_64-apple-driverkit19.0 */
-    #if __is_target_arch(x86_64) && __is_target_vendor(apple) && __is_target_os(driverkit)
-        #define TARGET_OS_OSX               0
-        #define TARGET_OS_IPHONE            0
-        #define TARGET_OS_IOS               0
-        #define TARGET_OS_WATCH             0
-        
-        #define TARGET_OS_TV                0
-        #define TARGET_OS_SIMULATOR         0
-        #define TARGET_OS_EMBEDDED          0
-        #define TARGET_OS_RTKIT             0
-        #define TARGET_OS_MACCATALYST       0
-        #define TARGET_OS_MACCATALYST            0
-        #ifndef TARGET_OS_UIKITFORMAC
-         #define TARGET_OS_UIKITFORMAC      0
-        #endif
-        #define TARGET_OS_DRIVERKIT         1
-        #define DYNAMIC_TARGETS_ENABLED     1
-    #endif
-
-    #endif /* #if __has_builtin(__is_target_environment) */
-   #endif /* #if __has_builtin(__is_target_os) */
-  #endif /* #if __has_builtin(__is_target_vendor) */
- #endif /* #if __has_builtin(__is_target_arch) */
-#endif /* #if defined(__has_builtin) */
-
-
-#ifndef DYNAMIC_TARGETS_ENABLED
- #define DYNAMIC_TARGETS_ENABLED   0
-#endif /* DYNAMIC_TARGETS_ENABLED */
-
-/*
- *    gcc based compiler used on Mac OS X
- */
-#if defined(__GNUC__) && ( defined(__APPLE_CPP__) || defined(__APPLE_CC__) || defined(__MACOS_CLASSIC__) )
-    #define TARGET_OS_MAC               1
-    #define TARGET_OS_WIN32             0
-    #define TARGET_OS_UNIX              0
-
-    #if !DYNAMIC_TARGETS_ENABLED
-        #define TARGET_OS_OSX               1
-        #define TARGET_OS_IPHONE            0
-        #define TARGET_OS_IOS               0
-        #define TARGET_OS_WATCH             0
-        
-        #define TARGET_OS_TV                0
-        #define TARGET_OS_MACCATALYST       0
-        #define TARGET_OS_MACCATALYST            0
-        #ifndef TARGET_OS_UIKITFORMAC
-         #define TARGET_OS_UIKITFORMAC      0
-        #endif
-        #define TARGET_OS_SIMULATOR         0
-        #define TARGET_OS_EMBEDDED          0 
-        #define TARGET_OS_RTKIT             0 
-        #define TARGET_OS_DRIVERKIT         0
-    #endif
-    
-    #define TARGET_IPHONE_SIMULATOR     TARGET_OS_SIMULATOR /* deprecated */
-    #define TARGET_OS_NANO              TARGET_OS_WATCH /* deprecated */ 
-    #define TARGET_ABI_USES_IOS_VALUES  (TARGET_OS_IPHONE && !TARGET_OS_MACCATALYST)
-    #if defined(__ppc__)
-        #define TARGET_CPU_PPC          1
-        #define TARGET_CPU_PPC64        0
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          0
-        #define TARGET_CPU_X86_64       0
-        #define TARGET_CPU_ARM          0
-        #define TARGET_CPU_ARM64        0
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0   
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_LITTLE_ENDIAN 0
-        #define TARGET_RT_BIG_ENDIAN    1
-        #define TARGET_RT_64_BIT        0
-        #ifdef __MACOS_CLASSIC__
-           #define TARGET_RT_MAC_CFM    1
-           #define TARGET_RT_MAC_MACHO  0
-        #else
-           #define TARGET_RT_MAC_CFM    0
-           #define TARGET_RT_MAC_MACHO  1
-       #endif
-    #elif defined(__ppc64__) 
-        #define TARGET_CPU_PPC          0
-        #define TARGET_CPU_PPC64        1
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          0
-        #define TARGET_CPU_X86_64       0
-        #define TARGET_CPU_ARM          0
-        #define TARGET_CPU_ARM64        0
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0   
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_LITTLE_ENDIAN 0
-        #define TARGET_RT_BIG_ENDIAN    1
-        #define TARGET_RT_64_BIT        1
-        #define TARGET_RT_MAC_CFM       0
-        #define TARGET_RT_MAC_MACHO     1
-    #elif defined(__i386__) 
-        #define TARGET_CPU_PPC          0
-        #define TARGET_CPU_PPC64        0
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          1
-        #define TARGET_CPU_X86_64       0
-        #define TARGET_CPU_ARM          0
-        #define TARGET_CPU_ARM64        0
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_MAC_CFM       0
-        #define TARGET_RT_MAC_MACHO     1
-        #define TARGET_RT_LITTLE_ENDIAN 1
-        #define TARGET_RT_BIG_ENDIAN    0
-        #define TARGET_RT_64_BIT        0
-    #elif defined(__x86_64__) 
-        #define TARGET_CPU_PPC          0
-        #define TARGET_CPU_PPC64        0
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          0
-        #define TARGET_CPU_X86_64       1
-        #define TARGET_CPU_ARM          0
-        #define TARGET_CPU_ARM64        0
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_MAC_CFM       0
-        #define TARGET_RT_MAC_MACHO     1
-        #define TARGET_RT_LITTLE_ENDIAN 1
-        #define TARGET_RT_BIG_ENDIAN    0
-        #define TARGET_RT_64_BIT        1
-    #elif defined(__arm__) 
-        #define TARGET_CPU_PPC          0
-        #define TARGET_CPU_PPC64        0
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          0
-        #define TARGET_CPU_X86_64       0
-        #define TARGET_CPU_ARM          1
-        #define TARGET_CPU_ARM64        0
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_MAC_CFM       0
-        #define TARGET_RT_MAC_MACHO     1
-        #define TARGET_RT_LITTLE_ENDIAN 1
-        #define TARGET_RT_BIG_ENDIAN    0
-        #define TARGET_RT_64_BIT        0
-    #elif defined(__arm64__)
-        #define TARGET_CPU_PPC          0
-        #define TARGET_CPU_PPC64        0
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          0
-        #define TARGET_CPU_X86_64       0
-        #define TARGET_CPU_ARM          0
-        #define TARGET_CPU_ARM64        1
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_MAC_CFM       0
-        #define TARGET_RT_MAC_MACHO     1
-        #define TARGET_RT_LITTLE_ENDIAN 1
-        #define TARGET_RT_BIG_ENDIAN    0
-        #if __LP64__
-          #define TARGET_RT_64_BIT      1
-        #else
-          #define TARGET_RT_64_BIT      0
-        #endif
-    #else
-        #error unrecognized GNU C compiler
-    #endif
-
-
-
-/*
- *   CodeWarrior compiler from Metrowerks/Motorola
- */
-#elif defined(__MWERKS__)
-    #define TARGET_OS_MAC               1
-    #define TARGET_OS_WIN32             0
-    #define TARGET_OS_UNIX              0
-    #define TARGET_OS_EMBEDDED          0
-    #if defined(__POWERPC__)
-        #define TARGET_CPU_PPC          1
-        #define TARGET_CPU_PPC64        0
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          0
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_LITTLE_ENDIAN 0
-        #define TARGET_RT_BIG_ENDIAN    1
-    #elif defined(__INTEL__)
-        #define TARGET_CPU_PPC          0
-        #define TARGET_CPU_PPC64        0
-        #define TARGET_CPU_68K          0
-        #define TARGET_CPU_X86          1
-        #define TARGET_CPU_MIPS         0
-        #define TARGET_CPU_SPARC        0
-        #define TARGET_CPU_ALPHA        0
-        #define TARGET_RT_LITTLE_ENDIAN 1
-        #define TARGET_RT_BIG_ENDIAN    0
-    #else
-        #error unknown Metrowerks CPU type
-    #endif
-    #define TARGET_RT_64_BIT            0
-    #ifdef __MACH__
-        #define TARGET_RT_MAC_CFM       0
-        #define TARGET_RT_MAC_MACHO     1
-    #else
-        #define TARGET_RT_MAC_CFM       1
-        #define TARGET_RT_MAC_MACHO     0
-    #endif
-
-/*
- *   unknown compiler
- */
-#else
-    #if defined(TARGET_CPU_PPC) && TARGET_CPU_PPC
-        #define TARGET_CPU_PPC64    0
-        #define TARGET_CPU_68K      0
-        #define TARGET_CPU_X86      0
-        #define TARGET_CPU_X86_64   0
-        #define TARGET_CPU_ARM      0
-        #define TARGET_CPU_ARM64    0
-        #define TARGET_CPU_MIPS     0
-        #define TARGET_CPU_SPARC    0
-        #define TARGET_CPU_ALPHA    0
-    #elif defined(TARGET_CPU_PPC64) && TARGET_CPU_PPC64
-        #define TARGET_CPU_PPC      0
-        #define TARGET_CPU_68K      0
-        #define TARGET_CPU_X86      0
-        #define TARGET_CPU_X86_64   0
-        #define TARGET_CPU_ARM      0
-        #define TARGET_CPU_ARM64    0
-        #define TARGET_CPU_MIPS     0
-        #define TARGET_CPU_SPARC    0
-        #define TARGET_CPU_ALPHA    0
-    #elif defined(TARGET_CPU_X86) && TARGET_CPU_X86
-        #define TARGET_CPU_PPC      0
-        #define TARGET_CPU_PPC64    0
-        #define TARGET_CPU_X86_64   0
-        #define TARGET_CPU_68K      0
-        #define TARGET_CPU_ARM      0
-        #define TARGET_CPU_ARM64    0
-        #define TARGET_CPU_MIPS     0
-        #define TARGET_CPU_SPARC    0
-        #define TARGET_CPU_ALPHA    0
-    #elif defined(TARGET_CPU_X86_64) && TARGET_CPU_X86_64
-        #define TARGET_CPU_PPC      0
-        #define TARGET_CPU_PPC64    0
-        #define TARGET_CPU_X86      0
-        #define TARGET_CPU_68K      0
-        #define TARGET_CPU_ARM      0
-        #define TARGET_CPU_ARM64    0
-        #define TARGET_CPU_MIPS     0
-        #define TARGET_CPU_SPARC    0
-        #define TARGET_CPU_ALPHA    0
-    #elif defined(TARGET_CPU_ARM) && TARGET_CPU_ARM
-        #define TARGET_CPU_PPC      0
-        #define TARGET_CPU_PPC64    0
-        #define TARGET_CPU_X86      0
-        #define TARGET_CPU_X86_64   0
-        #define TARGET_CPU_68K      0
-        #define TARGET_CPU_ARM64    0
-        #define TARGET_CPU_MIPS     0
-        #define TARGET_CPU_SPARC    0
-        #define TARGET_CPU_ALPHA    0
-    #elif defined(TARGET_CPU_ARM64) && TARGET_CPU_ARM64
-        #define TARGET_CPU_PPC      0
-        #define TARGET_CPU_PPC64    0
-        #define TARGET_CPU_X86      0
-        #define TARGET_CPU_X86_64   0
-        #define TARGET_CPU_68K      0
-        #define TARGET_CPU_ARM      0
-        #define TARGET_CPU_MIPS     0
-        #define TARGET_CPU_SPARC    0
-        #define TARGET_CPU_ALPHA    0
-    #else
-        /*
-            NOTE:   If your compiler errors out here then support for your compiler 
-            has not yet been added to TargetConditionals.h.  
-            
-            TargetConditionals.h is designed to be plug-and-play.  It auto detects
-            which compiler is being run and configures the TARGET_ conditionals
-            appropriately.  
-            
-            The short term work around is to set the TARGET_CPU_ and TARGET_OS_
-            on the command line to the compiler (e.g. -DTARGET_CPU_MIPS=1 -DTARGET_OS_UNIX=1)
-            
-            The long term solution is to add a new case to this file which
-            auto detects your compiler and sets up the TARGET_ conditionals.
-            Then submit the changes to Apple Computer.
-        */
-        #error TargetConditionals.h: unknown compiler (see comment above)
-        #define TARGET_CPU_PPC    0
-        #define TARGET_CPU_68K    0
-        #define TARGET_CPU_X86    0
-        #define TARGET_CPU_ARM    0
-        #define TARGET_CPU_ARM64  0
-        #define TARGET_CPU_MIPS   0
-        #define TARGET_CPU_SPARC  0
-        #define TARGET_CPU_ALPHA  0
-    #endif
-    #define TARGET_OS_MAC                1
-    #define TARGET_OS_WIN32              0
-    #define TARGET_OS_UNIX               0
-    #define TARGET_OS_EMBEDDED           0
-    #if TARGET_CPU_PPC || TARGET_CPU_PPC64
-        #define TARGET_RT_BIG_ENDIAN     1
-        #define TARGET_RT_LITTLE_ENDIAN  0
-    #else
-        #define TARGET_RT_BIG_ENDIAN     0
-        #define TARGET_RT_LITTLE_ENDIAN  1
-    #endif
-    #if TARGET_CPU_PPC64 || TARGET_CPU_X86_64
-        #define TARGET_RT_64_BIT         1
-    #else
-        #define TARGET_RT_64_BIT         0
-    #endif
-    #ifdef __MACH__
-        #define TARGET_RT_MAC_MACHO      1
-        #define TARGET_RT_MAC_CFM        0
-    #else
-        #define TARGET_RT_MAC_MACHO      0
-        #define TARGET_RT_MAC_CFM        1
-    #endif
-    
-#endif
-
-#endif  /* __TARGETCONDITIONALS__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/_ctermid.h b/lib/libc/include/x86_64-macos.10-none/_ctermid.h
deleted file mode 100644
index b941ea10d4..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/_ctermid.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (c) 2000, 2002-2006, 2008-2010, 2012 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _CTERMID_H_
-#define _CTERMID_H_
-char    *ctermid(char *);
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/assert.h b/lib/libc/include/x86_64-macos.10-none/assert.h
deleted file mode 100644
index e08d52cb28..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/assert.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/*-
- * Copyright (c) 1992, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)assert.h	8.2 (Berkeley) 1/21/94
- * $FreeBSD: src/include/assert.h,v 1.4 2002/03/23 17:24:53 imp Exp $
- */
-
-#include <sys/cdefs.h>
-#ifdef __cplusplus
-#include <stdlib.h>
-#endif /* __cplusplus */
-
-/*
- * Unlike other ANSI header files, <assert.h> may usefully be included
- * multiple times, with and without NDEBUG defined.
- */
-
-#undef assert
-#undef __assert
-
-#ifdef NDEBUG
-#define	assert(e)	((void)0)
-#else
-
-#ifndef __GNUC__
-
-__BEGIN_DECLS
-#ifndef __cplusplus
-void abort(void) __dead2 __cold;
-#endif /* !__cplusplus */
-int  printf(const char * __restrict, ...);
-__END_DECLS
-
-#define assert(e)  \
-    ((void) ((e) ? ((void)0) : __assert (#e, __FILE__, __LINE__)))
-#define __assert(e, file, line) \
-    ((void)printf ("%s:%d: failed assertion `%s'\n", file, line, e), abort())
-
-#else /* __GNUC__ */
-
-__BEGIN_DECLS
-void __assert_rtn(const char *, const char *, int, const char *) __dead2 __cold __disable_tail_calls;
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && ((__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__-0) < 1070)
-void __eprintf(const char *, const char *, unsigned, const char *) __dead2 __cold;
-#endif
-__END_DECLS
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && ((__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__-0) < 1070)
-#define __assert(e, file, line) \
-    __eprintf ("%s:%d: failed assertion `%s'\n", file, line, e)
-#else
-/* 8462256: modified __assert_rtn() replaces deprecated __eprintf() */
-#define __assert(e, file, line) \
-    __assert_rtn ((const char *)-1L, file, line, e)
-#endif
-
-#if __DARWIN_UNIX03
-#define	assert(e) \
-    (__builtin_expect(!(e), 0) ? __assert_rtn(__func__, __FILE__, __LINE__, #e) : (void)0)
-#else /* !__DARWIN_UNIX03 */
-#define assert(e)  \
-    (__builtin_expect(!(e), 0) ? __assert (#e, __FILE__, __LINE__) : (void)0)
-#endif /* __DARWIN_UNIX03 */
-
-#endif /* __GNUC__ */
-#endif /* NDEBUG */
-
-#ifndef _ASSERT_H_
-#define _ASSERT_H_
-
-#ifndef __cplusplus
-#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
-#define static_assert _Static_assert
-#endif /* __STDC_VERSION__ */
-#endif /* !__cplusplus */
-
-#endif /* _ASSERT_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/bsm/audit.h b/lib/libc/include/x86_64-macos.10-none/bsm/audit.h
deleted file mode 100644
index e65ccbfab6..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/bsm/audit.h
+++ /dev/null
@@ -1,378 +0,0 @@
-/*-
- * Copyright (c) 2005-2009 Apple Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1.  Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- * 2.  Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
- *     its contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * $P4: //depot/projects/trustedbsd/openbsm/sys/bsm/audit.h#10 $
- */
-
-#ifndef _BSM_AUDIT_H
-#define _BSM_AUDIT_H
-
-#include <sys/param.h>
-#include <sys/types.h>
-
-#define AUDIT_RECORD_MAGIC      0x828a0f1b
-#define MAX_AUDIT_RECORDS       20
-#define MAXAUDITDATA            (0x8000 - 1)
-#define MAX_AUDIT_RECORD_SIZE   MAXAUDITDATA
-#define MIN_AUDIT_FILE_SIZE     (512 * 1024)
-
-/*
- * Minimum noumber of free blocks on the filesystem containing the audit
- * log necessary to avoid a hard log rotation. DO NOT SET THIS VALUE TO 0
- * as the kernel does an unsigned compare, plus we want to leave a few blocks
- * free so userspace can terminate the log, etc.
- */
-#define AUDIT_HARD_LIMIT_FREE_BLOCKS    4
-
-/*
- * Triggers for the audit daemon.
- */
-#define AUDIT_TRIGGER_MIN               1
-#define AUDIT_TRIGGER_LOW_SPACE         1       /* Below low watermark. */
-#define AUDIT_TRIGGER_ROTATE_KERNEL     2       /* Kernel requests rotate. */
-#define AUDIT_TRIGGER_READ_FILE         3       /* Re-read config file. */
-#define AUDIT_TRIGGER_CLOSE_AND_DIE     4       /* Terminate audit. */
-#define AUDIT_TRIGGER_NO_SPACE          5       /* Below min free space. */
-#define AUDIT_TRIGGER_ROTATE_USER       6       /* User requests rotate. */
-#define AUDIT_TRIGGER_INITIALIZE        7       /* User initialize of auditd. */
-#define AUDIT_TRIGGER_EXPIRE_TRAILS     8       /* User expiration of trails. */
-#define AUDIT_TRIGGER_MAX               8
-
-/*
- * The special device filename (FreeBSD).
- */
-#define AUDITDEV_FILENAME       "audit"
-#define AUDIT_TRIGGER_FILE      ("/dev/" AUDITDEV_FILENAME)
-
-/*
- * Pre-defined audit IDs
- */
-#define AU_DEFAUDITID   (uid_t)(-1)
-#define AU_DEFAUDITSID   0
-#define AU_ASSIGN_ASID  -1
-
-/*
- * IPC types.
- */
-#define AT_IPC_MSG      ((unsigned char)1)      /* Message IPC id. */
-#define AT_IPC_SEM      ((unsigned char)2)      /* Semaphore IPC id. */
-#define AT_IPC_SHM      ((unsigned char)3)      /* Shared mem IPC id. */
-
-/*
- * Audit conditions.
- */
-#define AUC_UNSET               0
-#define AUC_AUDITING            1
-#define AUC_NOAUDIT             2
-#define AUC_DISABLED            -1
-
-/*
- * auditon(2) commands.
- */
-#define A_OLDGETPOLICY  2
-#define A_OLDSETPOLICY  3
-#define A_GETKMASK      4
-#define A_SETKMASK      5
-#define A_OLDGETQCTRL   6
-#define A_OLDSETQCTRL   7
-#define A_GETCWD        8
-#define A_GETCAR        9
-#define A_GETSTAT       12
-#define A_SETSTAT       13
-#define A_SETUMASK      14
-#define A_SETSMASK      15
-#define A_OLDGETCOND    20
-#define A_OLDSETCOND    21
-#define A_GETCLASS      22
-#define A_SETCLASS      23
-#define A_GETPINFO      24
-#define A_SETPMASK      25
-#define A_SETFSIZE      26
-#define A_GETFSIZE      27
-#define A_GETPINFO_ADDR 28
-#define A_GETKAUDIT     29
-#define A_SETKAUDIT     30
-#define A_SENDTRIGGER   31
-#define A_GETSINFO_ADDR 32
-#define A_GETPOLICY     33
-#define A_SETPOLICY     34
-#define A_GETQCTRL      35
-#define A_SETQCTRL      36
-#define A_GETCOND       37
-#define A_SETCOND       38
-#define A_GETSFLAGS     39
-#define A_SETSFLAGS     40
-#define A_GETCTLMODE    41
-#define A_SETCTLMODE    42
-#define A_GETEXPAFTER   43
-#define A_SETEXPAFTER   44
-
-/*
- * Audit policy controls.
- */
-#define AUDIT_CNT       0x0001
-#define AUDIT_AHLT      0x0002
-#define AUDIT_ARGV      0x0004
-#define AUDIT_ARGE      0x0008
-#define AUDIT_SEQ       0x0010
-#define AUDIT_WINDATA   0x0020
-#define AUDIT_USER      0x0040
-#define AUDIT_GROUP     0x0080
-#define AUDIT_TRAIL     0x0100
-#define AUDIT_PATH      0x0200
-#define AUDIT_SCNT      0x0400
-#define AUDIT_PUBLIC    0x0800
-#define AUDIT_ZONENAME  0x1000
-#define AUDIT_PERZONE   0x2000
-
-/*
- * Default audit queue control parameters.
- */
-#define AQ_HIWATER      100
-#define AQ_MAXHIGH      10000
-#define AQ_LOWATER      10
-#define AQ_BUFSZ        MAXAUDITDATA
-#define AQ_MAXBUFSZ     1048576
-
-/*
- * Default minimum percentage free space on file system.
- */
-#define AU_FS_MINFREE   20
-
-/*
- * Type definitions used indicating the length of variable length addresses
- * in tokens containing addresses, such as header fields.
- */
-#define AU_IPv4         4
-#define AU_IPv6         16
-
-/*
- * Reserved audit class mask indicating which classes are unable to have
- * events added or removed by unentitled processes.
- */
-#define AU_CLASS_MASK_RESERVED 0x10000000
-
-/*
- * Audit control modes
- */
-#define AUDIT_CTLMODE_NORMAL ((unsigned char)1)
-#define AUDIT_CTLMODE_EXTERNAL ((unsigned char)2)
-
-/*
- * Audit file expire_after op modes
- */
-#define AUDIT_EXPIRE_OP_AND ((unsigned char)0)
-#define AUDIT_EXPIRE_OP_OR ((unsigned char)1)
-
-__BEGIN_DECLS
-
-typedef uid_t           au_id_t;
-typedef pid_t           au_asid_t;
-typedef u_int16_t       au_event_t;
-typedef u_int16_t       au_emod_t;
-typedef u_int32_t       au_class_t;
-typedef u_int64_t       au_asflgs_t __attribute__ ((aligned(8)));
-typedef unsigned char   au_ctlmode_t;
-
-struct au_tid {
-	dev_t           port;
-	u_int32_t       machine;
-};
-typedef struct au_tid   au_tid_t;
-
-struct au_tid_addr {
-	dev_t           at_port;
-	u_int32_t       at_type;
-	u_int32_t       at_addr[4];
-};
-typedef struct au_tid_addr      au_tid_addr_t;
-
-struct au_mask {
-	unsigned int    am_success;     /* Success bits. */
-	unsigned int    am_failure;     /* Failure bits. */
-};
-typedef struct au_mask  au_mask_t;
-
-struct auditinfo {
-	au_id_t         ai_auid;        /* Audit user ID. */
-	au_mask_t       ai_mask;        /* Audit masks. */
-	au_tid_t        ai_termid;      /* Terminal ID. */
-	au_asid_t       ai_asid;        /* Audit session ID. */
-};
-typedef struct auditinfo        auditinfo_t;
-
-struct auditinfo_addr {
-	au_id_t         ai_auid;        /* Audit user ID. */
-	au_mask_t       ai_mask;        /* Audit masks. */
-	au_tid_addr_t   ai_termid;      /* Terminal ID. */
-	au_asid_t       ai_asid;        /* Audit session ID. */
-	au_asflgs_t     ai_flags;       /* Audit session flags. */
-};
-typedef struct auditinfo_addr   auditinfo_addr_t;
-
-struct auditpinfo {
-	pid_t           ap_pid;         /* ID of target process. */
-	au_id_t         ap_auid;        /* Audit user ID. */
-	au_mask_t       ap_mask;        /* Audit masks. */
-	au_tid_t        ap_termid;      /* Terminal ID. */
-	au_asid_t       ap_asid;        /* Audit session ID. */
-};
-typedef struct auditpinfo       auditpinfo_t;
-
-struct auditpinfo_addr {
-	pid_t           ap_pid;         /* ID of target process. */
-	au_id_t         ap_auid;        /* Audit user ID. */
-	au_mask_t       ap_mask;        /* Audit masks. */
-	au_tid_addr_t   ap_termid;      /* Terminal ID. */
-	au_asid_t       ap_asid;        /* Audit session ID. */
-	au_asflgs_t     ap_flags;       /* Audit session flags. */
-};
-typedef struct auditpinfo_addr  auditpinfo_addr_t;
-
-struct au_session {
-	auditinfo_addr_t        *as_aia_p;      /* Ptr to full audit info. */
-	au_mask_t                as_mask;       /* Process Audit Masks. */
-};
-typedef struct au_session       au_session_t;
-
-struct au_expire_after {
-	time_t age;             /* Age after which trail files should be expired */
-	size_t size;    /* Aggregate trail size when files should be expired */
-	unsigned char op_type; /* Operator used with the above values to determine when files should be expired */
-};
-typedef struct au_expire_after au_expire_after_t;
-
-/*
- * Contents of token_t are opaque outside of libbsm.
- */
-typedef struct au_token token_t;
-
-/*
- * Kernel audit queue control parameters:
- *                      Default:		Maximum:
- *      aq_hiwater:	AQ_HIWATER (100)	AQ_MAXHIGH (10000)
- *      aq_lowater:	AQ_LOWATER (10)		<aq_hiwater
- *      aq_bufsz:	AQ_BUFSZ (32767)	AQ_MAXBUFSZ (1048576)
- *      aq_delay:	20			20000 (not used)
- */
-struct au_qctrl {
-	int     aq_hiwater;     /* Max # of audit recs in queue when */
-	                        /* threads with new ARs get blocked. */
-
-	int     aq_lowater;     /* # of audit recs in queue when */
-	                        /* blocked threads get unblocked. */
-
-	int     aq_bufsz;       /* Max size of audit record for audit(2). */
-	int     aq_delay;       /* Queue delay (not used). */
-	int     aq_minfree;     /* Minimum filesystem percent free space. */
-};
-typedef struct au_qctrl au_qctrl_t;
-
-/*
- * Structure for the audit statistics.
- */
-struct audit_stat {
-	unsigned int    as_version;
-	unsigned int    as_numevent;
-	int             as_generated;
-	int             as_nonattrib;
-	int             as_kernel;
-	int             as_audit;
-	int             as_auditctl;
-	int             as_enqueue;
-	int             as_written;
-	int             as_wblocked;
-	int             as_rblocked;
-	int             as_dropped;
-	int             as_totalsize;
-	unsigned int    as_memused;
-};
-typedef struct audit_stat       au_stat_t;
-
-/*
- * Structure for the audit file statistics.
- */
-struct audit_fstat {
-	u_int64_t       af_filesz;
-	u_int64_t       af_currsz;
-};
-typedef struct audit_fstat      au_fstat_t;
-
-/*
- * Audit to event class mapping.
- */
-struct au_evclass_map {
-	au_event_t      ec_number;
-	au_class_t      ec_class;
-};
-typedef struct au_evclass_map   au_evclass_map_t;
-
-/*
- * Audit system calls.
- */
-#if !defined(_KERNEL) && !defined(KERNEL)
-int     audit(const void *, int);
-int     auditon(int, void *, int);
-int     auditctl(const char *);
-int     getauid(au_id_t *);
-int     setauid(const au_id_t *);
-int     getaudit_addr(struct auditinfo_addr *, int);
-int     setaudit_addr(const struct auditinfo_addr *, int);
-
-#if defined(__APPLE__)
-#include <Availability.h>
-
-/*
- * getaudit()/setaudit() are deprecated and have been replaced with
- * wrappers to the getaudit_addr()/setaudit_addr() syscalls above.
- */
-
-int     getaudit(struct auditinfo *)
-__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8,
-    __IPHONE_2_0, __IPHONE_6_0);
-int     setaudit(const struct auditinfo *)
-__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_0, __MAC_10_8,
-    __IPHONE_2_0, __IPHONE_6_0);
-#else
-
-int     getaudit(struct auditinfo *);
-int     setaudit(const struct auditinfo *);
-#endif /* !__APPLE__ */
-
-#ifdef __APPLE_API_PRIVATE
-#include <mach/port.h>
-mach_port_name_t audit_session_self(void);
-au_asid_t        audit_session_join(mach_port_name_t port);
-int              audit_session_port(au_asid_t asid, mach_port_name_t *portname);
-#endif /* __APPLE_API_PRIVATE */
-
-#endif /* defined(_KERNEL) || defined(KERNEL) */
-
-__END_DECLS
-
-#endif /* !_BSM_AUDIT_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/device/device_types.h b/lib/libc/include/x86_64-macos.10-none/device/device_types.h
deleted file mode 100644
index 2878666853..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/device/device_types.h
+++ /dev/null
@@ -1,118 +0,0 @@
-/*
- * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	Author: David B. Golub, Carnegie Mellon University
- *	Date:   3/89
- */
-
-#ifndef DEVICE_TYPES_H
-#define DEVICE_TYPES_H
-
-/*
- * Types for device interface.
- */
-#include <mach/std_types.h>
-#include <mach/mach_types.h>
-#include <mach/message.h>
-#include <mach/port.h>
-
-
-
-/*
- * IO buffer - out-of-line array of characters.
- */
-typedef char *  io_buf_ptr_t;
-
-/*
- * Some types for IOKit.
- */
-
-#ifdef IOKIT
-
-/* must match device_types.defs */
-typedef char                    io_name_t[128];
-typedef char                    io_string_t[512];
-typedef char                    io_string_inband_t[4096];
-typedef char                    io_struct_inband_t[4096];
-
-#if   __LP64__
-typedef uint64_t                io_user_scalar_t;
-typedef uint64_t                io_user_reference_t;
-typedef io_user_scalar_t        io_scalar_inband_t[16];
-typedef io_user_reference_t     io_async_ref_t[8];
-typedef io_user_scalar_t        io_scalar_inband64_t[16];
-typedef io_user_reference_t     io_async_ref64_t[8];
-#else
-typedef int                     io_user_scalar_t;
-typedef natural_t               io_user_reference_t;
-typedef io_user_scalar_t        io_scalar_inband_t[16];
-typedef io_user_reference_t     io_async_ref_t[8];
-typedef uint64_t                io_scalar_inband64_t[16];
-typedef uint64_t                io_async_ref64_t[8];
-#endif // __LP64__
-
-
-#ifndef __IOKIT_PORTS_DEFINED__
-#define __IOKIT_PORTS_DEFINED__
-typedef mach_port_t     io_object_t;
-#endif  /* __IOKIT_PORTS_DEFINED__ */
-
-
-#endif  /* IOKIT */
-
-#endif  /* DEVICE_TYPES_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/dispatch/dispatch.h b/lib/libc/include/x86_64-macos.10-none/dispatch/dispatch.h
deleted file mode 100644
index 7d5356aab6..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/dispatch/dispatch.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/*
- * Copyright (c) 2008-2013 Apple Inc. All rights reserved.
- *
- * @APPLE_APACHE_LICENSE_HEADER_START@
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @APPLE_APACHE_LICENSE_HEADER_END@
- */
-
-#ifndef __DISPATCH_PUBLIC__
-#define __DISPATCH_PUBLIC__
-
-#ifdef __APPLE__
-#include <Availability.h>
-#include <os/availability.h>
-#include <TargetConditionals.h>
-#include <os/base.h>
-#elif defined(_WIN32)
-#include <os/generic_win_base.h>
-#elif defined(__unix__)
-#include <os/generic_unix_base.h>
-#endif
-
-#include <sys/types.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <stdarg.h>
-#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
-#include <unistd.h>
-#endif
-#include <fcntl.h>
-
-#if (defined(__linux__) || defined(__FreeBSD__)) && defined(__has_feature)
-#if __has_feature(modules)
-#if !defined(__arm__)
-#include <stdio.h> // for off_t (to match Glibc.modulemap)
-#endif
-#endif
-#endif
-
-#define DISPATCH_API_VERSION 20181008
-
-#ifndef __DISPATCH_INDIRECT__
-#define __DISPATCH_INDIRECT__
-#endif
-
-#include <os/object.h>
-#include <dispatch/base.h>
-#include <dispatch/time.h>
-#include <dispatch/object.h>
-#include <dispatch/queue.h>
-#include <dispatch/block.h>
-#include <dispatch/source.h>
-#include <dispatch/group.h>
-#include <dispatch/semaphore.h>
-#include <dispatch/once.h>
-#include <dispatch/data.h>
-#include <dispatch/io.h>
-#include <dispatch/workloop.h>
-
-#undef __DISPATCH_INDIRECT__
-
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/execinfo.h b/lib/libc/include/x86_64-macos.10-none/execinfo.h
deleted file mode 100644
index 65d9d20486..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/execinfo.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (c) 2007 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-#ifndef _EXECINFO_H_
-#define _EXECINFO_H_ 1
-
-#include <sys/cdefs.h>
-#include <Availability.h>
-#include <os/base.h>
-#include <os/availability.h>
-#include <stdint.h>
-#include <uuid/uuid.h>
-
-__BEGIN_DECLS
-
-int backtrace(void**,int) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-
-API_AVAILABLE(macosx(10.14), ios(12.0), tvos(12.0), watchos(5.0))
-OS_EXPORT
-int backtrace_from_fp(void *startfp, void **array, int size);
-
-char** backtrace_symbols(void* const*,int) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-void backtrace_symbols_fd(void* const*,int,int) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
-
-struct image_offset {
-	/*
-	 * The UUID of the image.
-	 */
-	uuid_t uuid;
-
-	/*
-	 * The offset is relative to the __TEXT section of the image.
-	 */
-	uint32_t offset;
-};
-
-API_AVAILABLE(macosx(10.14), ios(12.0), tvos(12.0), watchos(5.0))
-OS_EXPORT
-void backtrace_image_offsets(void* const* array,
-		struct image_offset *image_offsets, int size);
-
-__END_DECLS
-
-#endif /* !_EXECINFO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/libkern/OSByteOrder.h b/lib/libc/include/x86_64-macos.10-none/libkern/OSByteOrder.h
deleted file mode 100644
index 25563e26e7..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/libkern/OSByteOrder.h
+++ /dev/null
@@ -1,305 +0,0 @@
-/*
- * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _OS_OSBYTEORDER_H
-#define _OS_OSBYTEORDER_H
-
-#include <stdint.h>
-#include <libkern/_OSByteOrder.h>
-
-/* Macros for swapping constant values in the preprocessing stage. */
-#define OSSwapConstInt16(x)     __DARWIN_OSSwapConstInt16(x)
-#define OSSwapConstInt32(x)     __DARWIN_OSSwapConstInt32(x)
-#define OSSwapConstInt64(x)     __DARWIN_OSSwapConstInt64(x)
-
-#if defined(__GNUC__)
-
-#if (defined(__i386__) || defined(__x86_64__))
-#include <libkern/i386/OSByteOrder.h>
-#else
-#include <libkern/machine/OSByteOrder.h>
-#endif
-
-#else /* ! __GNUC__ */
-
-#include <libkern/machine/OSByteOrder.h>
-
-#endif /* __GNUC__ */
-
-#define OSSwapInt16(x)  __DARWIN_OSSwapInt16(x)
-#define OSSwapInt32(x)  __DARWIN_OSSwapInt32(x)
-#define OSSwapInt64(x)  __DARWIN_OSSwapInt64(x)
-
-enum {
-	OSUnknownByteOrder,
-	OSLittleEndian,
-	OSBigEndian
-};
-
-OS_INLINE
-int32_t
-OSHostByteOrder(void)
-{
-#if defined(__LITTLE_ENDIAN__)
-	return OSLittleEndian;
-#elif defined(__BIG_ENDIAN__)
-	return OSBigEndian;
-#else
-	return OSUnknownByteOrder;
-#endif
-}
-
-#define OSReadBigInt(x, y)              OSReadBigInt32(x, y)
-#define OSWriteBigInt(x, y, z)          OSWriteBigInt32(x, y, z)
-#define OSSwapBigToHostInt(x)           OSSwapBigToHostInt32(x)
-#define OSSwapHostToBigInt(x)           OSSwapHostToBigInt32(x)
-#define OSReadLittleInt(x, y)           OSReadLittleInt32(x, y)
-#define OSWriteLittleInt(x, y, z)       OSWriteLittleInt32(x, y, z)
-#define OSSwapHostToLittleInt(x)        OSSwapHostToLittleInt32(x)
-#define OSSwapLittleToHostInt(x)        OSSwapLittleToHostInt32(x)
-
-/* Functions for loading native endian values. */
-
-OS_INLINE
-uint16_t
-_OSReadInt16(
-	const volatile void               * base,
-	uintptr_t                     byteOffset
-	)
-{
-	return *(volatile uint16_t *)((uintptr_t)base + byteOffset);
-}
-
-OS_INLINE
-uint32_t
-_OSReadInt32(
-	const volatile void               * base,
-	uintptr_t                     byteOffset
-	)
-{
-	return *(volatile uint32_t *)((uintptr_t)base + byteOffset);
-}
-
-OS_INLINE
-uint64_t
-_OSReadInt64(
-	const volatile void               * base,
-	uintptr_t                     byteOffset
-	)
-{
-	return *(volatile uint64_t *)((uintptr_t)base + byteOffset);
-}
-
-/* Functions for storing native endian values. */
-
-OS_INLINE
-void
-_OSWriteInt16(
-	volatile void               * base,
-	uintptr_t                     byteOffset,
-	uint16_t                      data
-	)
-{
-	*(volatile uint16_t *)((uintptr_t)base + byteOffset) = data;
-}
-
-OS_INLINE
-void
-_OSWriteInt32(
-	volatile void               * base,
-	uintptr_t                     byteOffset,
-	uint32_t                      data
-	)
-{
-	*(volatile uint32_t *)((uintptr_t)base + byteOffset) = data;
-}
-
-OS_INLINE
-void
-_OSWriteInt64(
-	volatile void               * base,
-	uintptr_t                     byteOffset,
-	uint64_t                      data
-	)
-{
-	*(volatile uint64_t *)((uintptr_t)base + byteOffset) = data;
-}
-
-#if             defined(__BIG_ENDIAN__)
-
-/* Functions for loading big endian to host endianess. */
-
-#define OSReadBigInt16(base, byteOffset) _OSReadInt16(base, byteOffset)
-#define OSReadBigInt32(base, byteOffset) _OSReadInt32(base, byteOffset)
-#define OSReadBigInt64(base, byteOffset) _OSReadInt64(base, byteOffset)
-
-/* Functions for storing host endianess to big endian. */
-
-#define OSWriteBigInt16(base, byteOffset, data) _OSWriteInt16(base, byteOffset, data)
-#define OSWriteBigInt32(base, byteOffset, data) _OSWriteInt32(base, byteOffset, data)
-#define OSWriteBigInt64(base, byteOffset, data) _OSWriteInt64(base, byteOffset, data)
-
-/* Functions for loading little endian to host endianess. */
-
-#define OSReadLittleInt16(base, byteOffset) OSReadSwapInt16(base, byteOffset)
-#define OSReadLittleInt32(base, byteOffset) OSReadSwapInt32(base, byteOffset)
-#define OSReadLittleInt64(base, byteOffset) OSReadSwapInt64(base, byteOffset)
-
-/* Functions for storing host endianess to little endian. */
-
-#define OSWriteLittleInt16(base, byteOffset, data) OSWriteSwapInt16(base, byteOffset, data)
-#define OSWriteLittleInt32(base, byteOffset, data) OSWriteSwapInt32(base, byteOffset, data)
-#define OSWriteLittleInt64(base, byteOffset, data) OSWriteSwapInt64(base, byteOffset, data)
-
-/* Host endianess to big endian byte swapping macros for constants. */
-
-#define OSSwapHostToBigConstInt16(x) ((uint16_t)(x))
-#define OSSwapHostToBigConstInt32(x) ((uint32_t)(x))
-#define OSSwapHostToBigConstInt64(x) ((uint64_t)(x))
-
-/* Generic host endianess to big endian byte swapping functions. */
-
-#define OSSwapHostToBigInt16(x) ((uint16_t)(x))
-#define OSSwapHostToBigInt32(x) ((uint32_t)(x))
-#define OSSwapHostToBigInt64(x) ((uint64_t)(x))
-
-/* Host endianess to little endian byte swapping macros for constants. */
-
-#define OSSwapHostToLittleConstInt16(x) OSSwapConstInt16(x)
-#define OSSwapHostToLittleConstInt32(x) OSSwapConstInt32(x)
-#define OSSwapHostToLittleConstInt64(x) OSSwapConstInt64(x)
-
-/* Generic host endianess to little endian byte swapping functions. */
-
-#define OSSwapHostToLittleInt16(x) OSSwapInt16(x)
-#define OSSwapHostToLittleInt32(x) OSSwapInt32(x)
-#define OSSwapHostToLittleInt64(x) OSSwapInt64(x)
-
-/* Big endian to host endianess byte swapping macros for constants. */
-
-#define OSSwapBigToHostConstInt16(x) ((uint16_t)(x))
-#define OSSwapBigToHostConstInt32(x) ((uint32_t)(x))
-#define OSSwapBigToHostConstInt64(x) ((uint64_t)(x))
-
-/* Generic big endian to host endianess byte swapping functions. */
-
-#define OSSwapBigToHostInt16(x) ((uint16_t)(x))
-#define OSSwapBigToHostInt32(x) ((uint32_t)(x))
-#define OSSwapBigToHostInt64(x) ((uint64_t)(x))
-
-/* Little endian to host endianess byte swapping macros for constants. */
-
-#define OSSwapLittleToHostConstInt16(x) OSSwapConstInt16(x)
-#define OSSwapLittleToHostConstInt32(x) OSSwapConstInt32(x)
-#define OSSwapLittleToHostConstInt64(x) OSSwapConstInt64(x)
-
-/* Generic little endian to host endianess byte swapping functions. */
-
-#define OSSwapLittleToHostInt16(x) OSSwapInt16(x)
-#define OSSwapLittleToHostInt32(x) OSSwapInt32(x)
-#define OSSwapLittleToHostInt64(x) OSSwapInt64(x)
-
-#elif           defined(__LITTLE_ENDIAN__)
-
-/* Functions for loading big endian to host endianess. */
-
-#define OSReadBigInt16(base, byteOffset) OSReadSwapInt16(base, byteOffset)
-#define OSReadBigInt32(base, byteOffset) OSReadSwapInt32(base, byteOffset)
-#define OSReadBigInt64(base, byteOffset) OSReadSwapInt64(base, byteOffset)
-
-/* Functions for storing host endianess to big endian. */
-
-#define OSWriteBigInt16(base, byteOffset, data) OSWriteSwapInt16(base, byteOffset, data)
-#define OSWriteBigInt32(base, byteOffset, data) OSWriteSwapInt32(base, byteOffset, data)
-#define OSWriteBigInt64(base, byteOffset, data) OSWriteSwapInt64(base, byteOffset, data)
-
-/* Functions for loading little endian to host endianess. */
-
-#define OSReadLittleInt16(base, byteOffset) _OSReadInt16(base, byteOffset)
-#define OSReadLittleInt32(base, byteOffset) _OSReadInt32(base, byteOffset)
-#define OSReadLittleInt64(base, byteOffset) _OSReadInt64(base, byteOffset)
-
-/* Functions for storing host endianess to little endian. */
-
-#define OSWriteLittleInt16(base, byteOffset, data) _OSWriteInt16(base, byteOffset, data)
-#define OSWriteLittleInt32(base, byteOffset, data) _OSWriteInt32(base, byteOffset, data)
-#define OSWriteLittleInt64(base, byteOffset, data) _OSWriteInt64(base, byteOffset, data)
-
-/* Host endianess to big endian byte swapping macros for constants. */
-
-#define OSSwapHostToBigConstInt16(x) OSSwapConstInt16(x)
-#define OSSwapHostToBigConstInt32(x) OSSwapConstInt32(x)
-#define OSSwapHostToBigConstInt64(x) OSSwapConstInt64(x)
-
-/* Generic host endianess to big endian byte swapping functions. */
-
-#define OSSwapHostToBigInt16(x) OSSwapInt16(x)
-#define OSSwapHostToBigInt32(x) OSSwapInt32(x)
-#define OSSwapHostToBigInt64(x) OSSwapInt64(x)
-
-/* Host endianess to little endian byte swapping macros for constants. */
-
-#define OSSwapHostToLittleConstInt16(x) ((uint16_t)(x))
-#define OSSwapHostToLittleConstInt32(x) ((uint32_t)(x))
-#define OSSwapHostToLittleConstInt64(x) ((uint64_t)(x))
-
-/* Generic host endianess to little endian byte swapping functions. */
-
-#define OSSwapHostToLittleInt16(x) ((uint16_t)(x))
-#define OSSwapHostToLittleInt32(x) ((uint32_t)(x))
-#define OSSwapHostToLittleInt64(x) ((uint64_t)(x))
-
-/* Big endian to host endianess byte swapping macros for constants. */
-
-#define OSSwapBigToHostConstInt16(x) OSSwapConstInt16(x)
-#define OSSwapBigToHostConstInt32(x) OSSwapConstInt32(x)
-#define OSSwapBigToHostConstInt64(x) OSSwapConstInt64(x)
-
-/* Generic big endian to host endianess byte swapping functions. */
-
-#define OSSwapBigToHostInt16(x) OSSwapInt16(x)
-#define OSSwapBigToHostInt32(x) OSSwapInt32(x)
-#define OSSwapBigToHostInt64(x) OSSwapInt64(x)
-
-/* Little endian to host endianess byte swapping macros for constants. */
-
-#define OSSwapLittleToHostConstInt16(x) ((uint16_t)(x))
-#define OSSwapLittleToHostConstInt32(x) ((uint32_t)(x))
-#define OSSwapLittleToHostConstInt64(x) ((uint64_t)(x))
-
-/* Generic little endian to host endianess byte swapping functions. */
-
-#define OSSwapLittleToHostInt16(x) ((uint16_t)(x))
-#define OSSwapLittleToHostInt32(x) ((uint32_t)(x))
-#define OSSwapLittleToHostInt64(x) ((uint64_t)(x))
-
-#else
-#error Unknown endianess.
-#endif
-
-#endif /* ! _OS_OSBYTEORDER_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/libkern/_OSByteOrder.h b/lib/libc/include/x86_64-macos.10-none/libkern/_OSByteOrder.h
deleted file mode 100644
index 06614c63ea..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/libkern/_OSByteOrder.h
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright (c) 2006 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _OS__OSBYTEORDER_H
-#define _OS__OSBYTEORDER_H
-
-/*
- * This header is normally included from <libkern/OSByteOrder.h>.  However,
- * <sys/_endian.h> also includes this in the case of little-endian
- * architectures, so that we can map OSByteOrder routines to the hton* and ntoh*
- * macros.  This results in the asymmetry below; we only include
- * <libkern/arch/_OSByteOrder.h> for little-endian architectures.
- */
-
-#include <sys/_types.h>
-
-/* Macros for swapping constant values in the preprocessing stage. */
-#define __DARWIN_OSSwapConstInt16(x) \
-    ((__uint16_t)((((__uint16_t)(x) & 0xff00) >> 8) | \
-	        (((__uint16_t)(x) & 0x00ff) << 8)))
-
-#define __DARWIN_OSSwapConstInt32(x) \
-    ((__uint32_t)((((__uint32_t)(x) & 0xff000000) >> 24) | \
-	        (((__uint32_t)(x) & 0x00ff0000) >>  8) | \
-	        (((__uint32_t)(x) & 0x0000ff00) <<  8) | \
-	        (((__uint32_t)(x) & 0x000000ff) << 24)))
-
-#define __DARWIN_OSSwapConstInt64(x) \
-    ((__uint64_t)((((__uint64_t)(x) & 0xff00000000000000ULL) >> 56) | \
-	        (((__uint64_t)(x) & 0x00ff000000000000ULL) >> 40) | \
-	        (((__uint64_t)(x) & 0x0000ff0000000000ULL) >> 24) | \
-	        (((__uint64_t)(x) & 0x000000ff00000000ULL) >>  8) | \
-	        (((__uint64_t)(x) & 0x00000000ff000000ULL) <<  8) | \
-	        (((__uint64_t)(x) & 0x0000000000ff0000ULL) << 24) | \
-	        (((__uint64_t)(x) & 0x000000000000ff00ULL) << 40) | \
-	        (((__uint64_t)(x) & 0x00000000000000ffULL) << 56)))
-
-#if defined(__GNUC__)
-
-#if defined(__i386__) || defined(__x86_64__)
-#include <libkern/i386/_OSByteOrder.h>
-#endif
-
-
-
-#define __DARWIN_OSSwapInt16(x) \
-    ((__uint16_t)(__builtin_constant_p(x) ? __DARWIN_OSSwapConstInt16(x) : _OSSwapInt16(x)))
-
-#define __DARWIN_OSSwapInt32(x) \
-    (__builtin_constant_p(x) ? __DARWIN_OSSwapConstInt32(x) : _OSSwapInt32(x))
-
-#define __DARWIN_OSSwapInt64(x) \
-    (__builtin_constant_p(x) ? __DARWIN_OSSwapConstInt64(x) : _OSSwapInt64(x))
-
-#else /* ! __GNUC__ */
-
-#if defined(__i386__) || defined(__x86_64__)
-
-#if !defined(__DARWIN_OS_INLINE)
-# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
-#        define __DARWIN_OS_INLINE static inline
-# elif defined(__MWERKS__) || defined(__cplusplus)
-#        define __DARWIN_OS_INLINE static inline
-# else
-#        define __DARWIN_OS_INLINE static __inline__
-# endif
-#endif
-
-__DARWIN_OS_INLINE
-uint16_t
-_OSSwapInt16(
-	uint16_t                    data
-	)
-{
-	return __DARWIN_OSSwapConstInt16(data);
-}
-
-__DARWIN_OS_INLINE
-uint32_t
-_OSSwapInt32(
-	uint32_t                    data
-	)
-{
-	return __DARWIN_OSSwapConstInt32(data);
-}
-
-__DARWIN_OS_INLINE
-uint64_t
-_OSSwapInt64(
-	uint64_t                    data
-	)
-{
-	return __DARWIN_OSSwapConstInt64(data);
-}
-#endif
-
-#define __DARWIN_OSSwapInt16(x) _OSSwapInt16(x)
-
-#define __DARWIN_OSSwapInt32(x) _OSSwapInt32(x)
-
-#define __DARWIN_OSSwapInt64(x) _OSSwapInt64(x)
-
-#endif /* __GNUC__ */
-
-#endif /* ! _OS__OSBYTEORDER_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach-o/compact_unwind_encoding.h b/lib/libc/include/x86_64-macos.10-none/mach-o/compact_unwind_encoding.h
deleted file mode 100644
index 3c37bb3bc7..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach-o/compact_unwind_encoding.h
+++ /dev/null
@@ -1,427 +0,0 @@
-/* -*- mode: C; c-basic-offset: 4; tab-width: 4 -*-
- *
- * Copyright (c) 2008-2011 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
- 
-
-#ifndef __COMPACT_UNWIND_ENCODING__
-#define __COMPACT_UNWIND_ENCODING__
-
-#include <stdint.h>
-
-
-
-//
-// Compilers can emit standard Dwarf FDEs in the __TEXT,__eh_frame section 
-// of object files. Or compilers can emit compact unwind information in 
-// the __LD,__compact_unwind section.
-//
-// When the linker creates a final linked image, it will create a  
-// __TEXT,__unwind_info section.  This section is a small and fast way for the 
-// runtime to access unwind info for any given function.  If the compiler emitted
-// compact unwind info for the function, that compact unwind info will be encoded
-// in the __TEXT,__unwind_info section. If the compiler emitted dwarf unwind info,
-// the __TEXT,__unwind_info section will contain the offset of the FDE in the
-// __TEXT,__eh_frame section in the final linked image.  
-//
-// Note: Previously, the linker would transform some dwarf unwind infos into 
-//       compact unwind info.  But that is fragile and no longer done.
-
-
-//
-// The compact unwind endoding is a 32-bit value which encoded in an architecture
-// specific way, which registers to restore from where, and how to unwind out
-// of the function.  
-//
-typedef uint32_t compact_unwind_encoding_t;
-
-
-// architecture independent bits
-enum {
-    UNWIND_IS_NOT_FUNCTION_START           = 0x80000000,
-    UNWIND_HAS_LSDA                        = 0x40000000,
-    UNWIND_PERSONALITY_MASK                = 0x30000000,
-};
-
-
-
-
-//
-// x86
-//
-// 1-bit: start
-// 1-bit: has lsda
-// 2-bit: personality index
-//
-// 4-bits: 0=old, 1=ebp based, 2=stack-imm, 3=stack-ind, 4=dwarf
-//  ebp based:
-//        15-bits (5*3-bits per reg) register permutation
-//        8-bits for stack offset
-//  frameless:
-//        8-bits stack size
-//        3-bits stack adjust
-//        3-bits register count
-//        10-bits register permutation
-//
-enum {
-    UNWIND_X86_MODE_MASK                         = 0x0F000000,
-    UNWIND_X86_MODE_EBP_FRAME                    = 0x01000000,
-    UNWIND_X86_MODE_STACK_IMMD                   = 0x02000000,
-    UNWIND_X86_MODE_STACK_IND                    = 0x03000000,
-    UNWIND_X86_MODE_DWARF                        = 0x04000000,
-    
-    UNWIND_X86_EBP_FRAME_REGISTERS               = 0x00007FFF,
-    UNWIND_X86_EBP_FRAME_OFFSET                  = 0x00FF0000,
-    
-    UNWIND_X86_FRAMELESS_STACK_SIZE              = 0x00FF0000,
-    UNWIND_X86_FRAMELESS_STACK_ADJUST            = 0x0000E000,
-    UNWIND_X86_FRAMELESS_STACK_REG_COUNT         = 0x00001C00,
-    UNWIND_X86_FRAMELESS_STACK_REG_PERMUTATION   = 0x000003FF,
-    
-    UNWIND_X86_DWARF_SECTION_OFFSET              = 0x00FFFFFF,
-};
-
-enum {
-    UNWIND_X86_REG_NONE     = 0,
-    UNWIND_X86_REG_EBX      = 1,
-    UNWIND_X86_REG_ECX      = 2,
-    UNWIND_X86_REG_EDX      = 3,
-    UNWIND_X86_REG_EDI      = 4,
-    UNWIND_X86_REG_ESI      = 5,
-    UNWIND_X86_REG_EBP      = 6,
-};
-
-//
-// For x86 there are four modes for the compact unwind encoding:
-// UNWIND_X86_MODE_EBP_FRAME:
-//    EBP based frame where EBP is push on stack immediately after return address, 
-//    then ESP is moved to EBP. Thus, to unwind ESP is restored with the current 
-//    EPB value, then EBP is restored by popping off the stack, and the return 
-//    is done by popping the stack once more into the pc.
-//    All non-volatile registers that need to be restored must have been saved
-//    in a small range in the stack that starts EBP-4 to EBP-1020.  The offset/4 
-//    is encoded in the UNWIND_X86_EBP_FRAME_OFFSET bits.  The registers saved
-//    are encoded in the UNWIND_X86_EBP_FRAME_REGISTERS bits as five 3-bit entries.
-//    Each entry contains which register to restore.  
-// UNWIND_X86_MODE_STACK_IMMD:
-//    A "frameless" (EBP not used as frame pointer) function with a small 
-//    constant stack size.  To return, a constant (encoded in the compact 
-//    unwind encoding) is added to the ESP. Then the return is done by 
-//    popping the stack into the pc.
-//    All non-volatile registers that need to be restored must have been saved
-//    on the stack immediately after the return address.  The stack_size/4 is
-//    encoded in the UNWIND_X86_FRAMELESS_STACK_SIZE (max stack size is 1024).
-//    The number of registers saved is encoded in UNWIND_X86_FRAMELESS_STACK_REG_COUNT.
-//    UNWIND_X86_FRAMELESS_STACK_REG_PERMUTATION constains which registers were
-//    saved and their order.  
-// UNWIND_X86_MODE_STACK_IND:
-//    A "frameless" (EBP not used as frame pointer) function large constant 
-//    stack size.  This case is like the previous, except the stack size is too
-//    large to encode in the compact unwind encoding.  Instead it requires that 
-//    the function contains "subl $nnnnnnnn,ESP" in its prolog.  The compact 
-//    encoding contains the offset to the nnnnnnnn value in the function in
-//    UNWIND_X86_FRAMELESS_STACK_SIZE.  
-// UNWIND_X86_MODE_DWARF:
-//    No compact unwind encoding is available.  Instead the low 24-bits of the
-//    compact encoding is the offset of the dwarf FDE in the __eh_frame section.
-//    This mode is never used in object files.  It is only generated by the 
-//    linker in final linked images which have only dwarf unwind info for a
-//    function.
-//
-// The following is the algorithm used to create the permutation encoding used
-// with frameless stacks.  It is passed the number of registers to be saved and
-// an array of the register numbers saved.
-//
-//uint32_t permute_encode(uint32_t registerCount, const uint32_t registers[6])
-//{
-//    uint32_t renumregs[6];
-//    for (int i=6-registerCount; i < 6; ++i) {
-//        int countless = 0;
-//        for (int j=6-registerCount; j < i; ++j) {
-//            if ( registers[j] < registers[i] )
-//                ++countless;
-//        }
-//        renumregs[i] = registers[i] - countless -1;
-//    }
-//    uint32_t permutationEncoding = 0;
-//    switch ( registerCount ) {
-//        case 6:
-//            permutationEncoding |= (120*renumregs[0] + 24*renumregs[1] 
-//                                    + 6*renumregs[2] + 2*renumregs[3] 
-//                                      + renumregs[4]);
-//            break;
-//        case 5:
-//            permutationEncoding |= (120*renumregs[1] + 24*renumregs[2] 
-//                                    + 6*renumregs[3] + 2*renumregs[4] 
-//                                      + renumregs[5]);
-//            break;
-//        case 4:
-//            permutationEncoding |= (60*renumregs[2] + 12*renumregs[3] 
-//                                   + 3*renumregs[4] + renumregs[5]);
-//            break;
-//        case 3:
-//            permutationEncoding |= (20*renumregs[3] + 4*renumregs[4] 
-//                                     + renumregs[5]);
-//            break;
-//        case 2:
-//            permutationEncoding |= (5*renumregs[4] + renumregs[5]);
-//            break;
-//        case 1:
-//            permutationEncoding |= (renumregs[5]);
-//            break;
-//    }
-//    return permutationEncoding;
-//}
-//
-
-
-
-
-//
-// x86_64
-//
-// 1-bit: start
-// 1-bit: has lsda
-// 2-bit: personality index
-//
-// 4-bits: 0=old, 1=rbp based, 2=stack-imm, 3=stack-ind, 4=dwarf
-//  rbp based:
-//        15-bits (5*3-bits per reg) register permutation
-//        8-bits for stack offset
-//  frameless:
-//        8-bits stack size
-//        3-bits stack adjust
-//        3-bits register count
-//        10-bits register permutation
-//
-enum {
-    UNWIND_X86_64_MODE_MASK                         = 0x0F000000,
-    UNWIND_X86_64_MODE_RBP_FRAME                    = 0x01000000,
-    UNWIND_X86_64_MODE_STACK_IMMD                   = 0x02000000,
-    UNWIND_X86_64_MODE_STACK_IND                    = 0x03000000,
-    UNWIND_X86_64_MODE_DWARF                        = 0x04000000,
-    
-    UNWIND_X86_64_RBP_FRAME_REGISTERS               = 0x00007FFF,
-    UNWIND_X86_64_RBP_FRAME_OFFSET                  = 0x00FF0000,
-
-    UNWIND_X86_64_FRAMELESS_STACK_SIZE              = 0x00FF0000,
-    UNWIND_X86_64_FRAMELESS_STACK_ADJUST            = 0x0000E000,
-    UNWIND_X86_64_FRAMELESS_STACK_REG_COUNT         = 0x00001C00,
-    UNWIND_X86_64_FRAMELESS_STACK_REG_PERMUTATION   = 0x000003FF,
-
-    UNWIND_X86_64_DWARF_SECTION_OFFSET              = 0x00FFFFFF,
-};
-
-enum {
-    UNWIND_X86_64_REG_NONE       = 0,
-    UNWIND_X86_64_REG_RBX        = 1,
-    UNWIND_X86_64_REG_R12        = 2,
-    UNWIND_X86_64_REG_R13        = 3,
-    UNWIND_X86_64_REG_R14        = 4,
-    UNWIND_X86_64_REG_R15        = 5,
-    UNWIND_X86_64_REG_RBP        = 6,
-};
-//
-// For x86_64 there are four modes for the compact unwind encoding:
-// UNWIND_X86_64_MODE_RBP_FRAME:
-//    RBP based frame where RBP is push on stack immediately after return address, 
-//    then RSP is moved to RBP. Thus, to unwind RSP is restored with the current 
-//    EPB value, then RBP is restored by popping off the stack, and the return 
-//    is done by popping the stack once more into the pc.
-//    All non-volatile registers that need to be restored must have been saved
-//    in a small range in the stack that starts RBP-8 to RBP-1020.  The offset/4 
-//    is encoded in the UNWIND_X86_64_RBP_FRAME_OFFSET bits.  The registers saved
-//    are encoded in the UNWIND_X86_64_RBP_FRAME_REGISTERS bits as five 3-bit entries.
-//    Each entry contains which register to restore.  
-// UNWIND_X86_64_MODE_STACK_IMMD:
-//    A "frameless" (RBP not used as frame pointer) function with a small 
-//    constant stack size.  To return, a constant (encoded in the compact 
-//    unwind encoding) is added to the RSP. Then the return is done by 
-//    popping the stack into the pc.
-//    All non-volatile registers that need to be restored must have been saved
-//    on the stack immediately after the return address.  The stack_size/4 is
-//    encoded in the UNWIND_X86_64_FRAMELESS_STACK_SIZE (max stack size is 1024).
-//    The number of registers saved is encoded in UNWIND_X86_64_FRAMELESS_STACK_REG_COUNT.
-//    UNWIND_X86_64_FRAMELESS_STACK_REG_PERMUTATION constains which registers were
-//    saved and their order.  
-// UNWIND_X86_64_MODE_STACK_IND:
-//    A "frameless" (RBP not used as frame pointer) function large constant 
-//    stack size.  This case is like the previous, except the stack size is too
-//    large to encode in the compact unwind encoding.  Instead it requires that 
-//    the function contains "subq $nnnnnnnn,RSP" in its prolog.  The compact 
-//    encoding contains the offset to the nnnnnnnn value in the function in
-//    UNWIND_X86_64_FRAMELESS_STACK_SIZE.  
-// UNWIND_X86_64_MODE_DWARF:
-//    No compact unwind encoding is available.  Instead the low 24-bits of the
-//    compact encoding is the offset of the dwarf FDE in the __eh_frame section.
-//    This mode is never used in object files.  It is only generated by the 
-//    linker in final linked images which have only dwarf unwind info for a
-//    function.
-//
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-//
-//  Relocatable Object Files: __LD,__compact_unwind
-//
-////////////////////////////////////////////////////////////////////////////////
-
-//
-// A compiler can generated compact unwind information for a function by adding
-// a "row" to the __LD,__compact_unwind section.  This section has the 
-// S_ATTR_DEBUG bit set, so the section will be ignored by older linkers. 
-// It is removed by the new linker, so never ends up in final executables. 
-// This section is a table, initially with one row per function (that needs 
-// unwind info).  The table columns and some conceptual entries are:
-//
-//	   range-start               pointer to start of function/range
-//     range-length              
-//     compact-unwind-encoding   32-bit encoding  
-//     personality-function      or zero if no personality function
-//     lsda                      or zero if no LSDA data
-//
-// The length and encoding fields are 32-bits.  The other are all pointer sized. 
-//
-// In x86_64 assembly, these entry would look like:
-//
-//     .section __LD,__compact_unwind,regular,debug
-//
-//     #compact unwind for _foo
-//     .quad    _foo
-//     .set     L1,LfooEnd-_foo
-//     .long    L1
-//     .long    0x01010001
-//     .quad    0
-//     .quad    0
-//
-//     #compact unwind for _bar
-//     .quad    _bar
-//     .set     L2,LbarEnd-_bar
-//     .long    L2
-//     .long    0x01020011
-//     .quad    __gxx_personality
-//     .quad    except_tab1
-//
-//
-// Notes: There is no need for any labels in the the __compact_unwind section.  
-//        The use of the .set directive is to force the evaluation of the 
-//        range-length at assembly time, instead of generating relocations.
-//
-// To support future compiler optimizations where which non-volatile registers 
-// are saved changes within a function (e.g. delay saving non-volatiles until
-// necessary), there can by multiple lines in the __compact_unwind table for one
-// function, each with a different (non-overlapping) range and each with 
-// different compact unwind encodings that correspond to the non-volatiles 
-// saved at that range of the function.
-//
-// If a particular function is so wacky that there is no compact unwind way
-// to encode it, then the compiler can emit traditional dwarf unwind info.  
-// The runtime will use which ever is available.
-//
-// Runtime support for compact unwind encodings are only available on 10.6 
-// and later.  So, the compiler should not generate it when targeting pre-10.6. 
-
-
-
-
-////////////////////////////////////////////////////////////////////////////////
-//
-//  Final Linked Images: __TEXT,__unwind_info
-//
-////////////////////////////////////////////////////////////////////////////////
-
-//
-// The __TEXT,__unwind_info section is laid out for an efficient two level lookup.
-// The header of the section contains a coarse index that maps function address
-// to the page (4096 byte block) containing the unwind info for that function.  
-//
-
-#define UNWIND_SECTION_VERSION 1
-struct unwind_info_section_header
-{
-    uint32_t    version;            // UNWIND_SECTION_VERSION
-    uint32_t    commonEncodingsArraySectionOffset;
-    uint32_t    commonEncodingsArrayCount;
-    uint32_t    personalityArraySectionOffset;
-    uint32_t    personalityArrayCount;
-    uint32_t    indexSectionOffset;
-    uint32_t    indexCount;
-    // compact_unwind_encoding_t[]
-    // uintptr_t personalities[]
-    // unwind_info_section_header_index_entry[]
-    // unwind_info_section_header_lsda_index_entry[]
-};
-
-struct unwind_info_section_header_index_entry 
-{
-    uint32_t        functionOffset;
-    uint32_t        secondLevelPagesSectionOffset;  // section offset to start of regular or compress page
-    uint32_t        lsdaIndexArraySectionOffset;    // section offset to start of lsda_index array for this range
-};
-
-struct unwind_info_section_header_lsda_index_entry 
-{
-    uint32_t        functionOffset;
-    uint32_t        lsdaOffset;
-};
-
-//
-// There are two kinds of second level index pages: regular and compressed.
-// A compressed page can hold up to 1021 entries, but it cannot be used
-// if too many different encoding types are used.  The regular page holds
-// 511 entries.  
-//
-
-struct unwind_info_regular_second_level_entry 
-{
-    uint32_t                    functionOffset;
-    compact_unwind_encoding_t    encoding;
-};
-
-#define UNWIND_SECOND_LEVEL_REGULAR 2
-struct unwind_info_regular_second_level_page_header
-{
-    uint32_t    kind;    // UNWIND_SECOND_LEVEL_REGULAR
-    uint16_t    entryPageOffset;
-    uint16_t    entryCount;
-    // entry array
-};
-
-#define UNWIND_SECOND_LEVEL_COMPRESSED 3
-struct unwind_info_compressed_second_level_page_header
-{
-    uint32_t    kind;    // UNWIND_SECOND_LEVEL_COMPRESSED
-    uint16_t    entryPageOffset;
-    uint16_t    entryCount;
-    uint16_t    encodingsPageOffset;
-    uint16_t    encodingsCount;
-    // 32-bit entry array    
-    // encodings array
-};
-
-#define UNWIND_INFO_COMPRESSED_ENTRY_FUNC_OFFSET(entry)            (entry & 0x00FFFFFF)
-#define UNWIND_INFO_COMPRESSED_ENTRY_ENCODING_INDEX(entry)        ((entry >> 24) & 0xFF)
-
-
-
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach-o/dyld.h b/lib/libc/include/x86_64-macos.10-none/mach-o/dyld.h
deleted file mode 100644
index 0b293cbd09..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach-o/dyld.h
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * Copyright (c) 1999-2008 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-#ifndef _MACH_O_DYLD_H_
-#define _MACH_O_DYLD_H_
-
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-
-#include <mach-o/loader.h>
-#include <Availability.h>
-
-#if __cplusplus
-extern "C" {
-#endif 
-
-#ifdef __DRIVERKIT_19_0
- #define DYLD_DRIVERKIT_UNAVAILABLE __API_UNAVAILABLE(driverkit)
-#else
- #define DYLD_DRIVERKIT_UNAVAILABLE
-#endif
-
-/*
- * The following functions allow you to iterate through all loaded images.  
- * This is not a thread safe operation.  Another thread can add or remove
- * an image during the iteration.  
- *
- * Many uses of these routines can be replace by a call to dladdr() which 
- * will return the mach_header and name of an image, given an address in 
- * the image. dladdr() is thread safe.
- */
-extern uint32_t                    _dyld_image_count(void)                              __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-extern const struct mach_header*   _dyld_get_image_header(uint32_t image_index)         __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-extern intptr_t                    _dyld_get_image_vmaddr_slide(uint32_t image_index)   __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-extern const char*                 _dyld_get_image_name(uint32_t image_index)           __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-
-
-/*
- * The following functions allow you to install callbacks which will be called   
- * by dyld whenever an image is loaded or unloaded.  During a call to _dyld_register_func_for_add_image()
- * the callback func is called for every existing image.  Later, it is called as each new image
- * is loaded and bound (but initializers not yet run).  The callback registered with
- * _dyld_register_func_for_remove_image() is called after any terminators in an image are run
- * and before the image is un-memory-mapped.
- */
-extern void _dyld_register_func_for_add_image(void (*func)(const struct mach_header* mh, intptr_t vmaddr_slide))    __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-extern void _dyld_register_func_for_remove_image(void (*func)(const struct mach_header* mh, intptr_t vmaddr_slide)) __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-
-
-/*
- * NSVersionOfRunTimeLibrary() returns the current_version number of the currently dylib 
- * specifed by the libraryName.  The libraryName parameter would be "bar" for /path/libbar.3.dylib and
- * "Foo" for /path/Foo.framework/Versions/A/Foo.  It returns -1 if no such library is loaded.
- */
-extern int32_t NSVersionOfRunTimeLibrary(const char* libraryName)            __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-
-
-/*
- * NSVersionOfLinkTimeLibrary() returns the current_version number that the main executable was linked
- * against at build time.  The libraryName parameter would be "bar" for /path/libbar.3.dylib and
- * "Foo" for /path/Foo.framework/Versions/A/Foo.  It returns -1 if the main executable did not link
- * against the specified library.
- */
-extern int32_t NSVersionOfLinkTimeLibrary(const char* libraryName)           __OSX_AVAILABLE_STARTING(__MAC_10_1, __IPHONE_2_0);
-
-
-/*
- * _NSGetExecutablePath() copies the path of the main executable into the buffer. The bufsize parameter
- * should initially be the size of the buffer.  The function returns 0 if the path was successfully copied,
- * and *bufsize is left unchanged. It returns -1 if the buffer is not large enough, and *bufsize is set 
- * to the size required. 
- * 
- * Note that _NSGetExecutablePath will return "a path" to the executable not a "real path" to the executable. 
- * That is the path may be a symbolic link and not the real file. With deep directories the total bufsize 
- * needed could be more than MAXPATHLEN.
- */
-extern int _NSGetExecutablePath(char* buf, uint32_t* bufsize)                 __OSX_AVAILABLE_STARTING(__MAC_10_2, __IPHONE_2_0);
-
-
-
-/*
- * Registers a function to be called when the current thread terminates.
- * Called by c++ compiler to implement destructors on thread_local object variables.
- */
-extern void _tlv_atexit(void (*termFunc)(void* objAddr), void* objAddr)      __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0);
-
-
-/*
- * Never called. On-disk thread local variables contain a pointer to this.  Once
- * the thread local is prepared, the pointer changes to a real handler such as tlv_get_addr.
- */
-extern void _tlv_bootstrap(void)                                             __OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0) DYLD_DRIVERKIT_UNAVAILABLE ;
-
-/*
- * The following dyld API's are deprecated as of Mac OS X 10.5.  They are either  
- * no longer necessary or are superceeded by dlopen and friends in <dlfcn.h>.
- * dlopen/dlsym/dlclose have been available since Mac OS X 10.3 and work with 
- * dylibs and bundles.  
- *
- *    NSAddImage                           -> dlopen
- *    NSLookupSymbolInImage                -> dlsym
- *    NSCreateObjectFileImageFromFile      -> dlopen
- *    NSDestroyObjectFileImage             -> dlclose
- *    NSLinkModule                         -> not needed when dlopen used
- *    NSUnLinkModule                       -> not needed when dlclose used
- *    NSLookupSymbolInModule               -> dlsym
- *    _dyld_image_containing_address       -> dladdr
- *    NSLinkEditError                      -> dlerror
- *
- */
-
-#ifndef ENUM_DYLD_BOOL
-#define ENUM_DYLD_BOOL
-  #undef FALSE
-  #undef TRUE
-  enum DYLD_BOOL { FALSE, TRUE };
-#endif /* ENUM_DYLD_BOOL */
-
-
-/* Object file image API */
-typedef enum {
-    NSObjectFileImageFailure, /* for this a message is printed on stderr */
-    NSObjectFileImageSuccess,
-    NSObjectFileImageInappropriateFile,
-    NSObjectFileImageArch,
-    NSObjectFileImageFormat, /* for this a message is printed on stderr */
-    NSObjectFileImageAccess
-} NSObjectFileImageReturnCode;
-
-typedef struct __NSObjectFileImage* NSObjectFileImage;
-
-
-
-/* NSObjectFileImage can only be used with MH_BUNDLE files */
-extern NSObjectFileImageReturnCode NSCreateObjectFileImageFromFile(const char* pathName, NSObjectFileImage *objectFileImage)               __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlopen()");
-extern NSObjectFileImageReturnCode NSCreateObjectFileImageFromMemory(const void *address, size_t size, NSObjectFileImage *objectFileImage) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-extern bool                        NSDestroyObjectFileImage(NSObjectFileImage objectFileImage)                                             __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlclose()");
-
-extern uint32_t     NSSymbolDefinitionCountInObjectFileImage(NSObjectFileImage objectFileImage)                   __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-extern const char*  NSSymbolDefinitionNameInObjectFileImage(NSObjectFileImage objectFileImage, uint32_t ordinal)  __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-extern uint32_t     NSSymbolReferenceCountInObjectFileImage(NSObjectFileImage objectFileImage)                    __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-extern const char*  NSSymbolReferenceNameInObjectFileImage(NSObjectFileImage objectFileImage, uint32_t ordinal, bool *tentative_definition) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-extern bool         NSIsSymbolDefinedInObjectFileImage(NSObjectFileImage objectFileImage, const char* symbolName) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern void*        NSGetSectionDataInObjectFileImage(NSObjectFileImage objectFileImage, const char* segmentName, const char* sectionName, size_t *size) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "getsectiondata()");
-
-typedef struct __NSModule* NSModule;
-extern const char*  NSNameOfModule(NSModule m)         __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-extern const char*  NSLibraryNameForModule(NSModule m) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-
-extern NSModule NSLinkModule(NSObjectFileImage objectFileImage, const char* moduleName, uint32_t options) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlopen()");
-#define NSLINKMODULE_OPTION_NONE                         0x0
-#define NSLINKMODULE_OPTION_BINDNOW                      0x1
-#define NSLINKMODULE_OPTION_PRIVATE                      0x2
-#define NSLINKMODULE_OPTION_RETURN_ON_ERROR              0x4
-#define NSLINKMODULE_OPTION_DONT_CALL_MOD_INIT_ROUTINES  0x8
-#define NSLINKMODULE_OPTION_TRAILING_PHYS_NAME          0x10
-
-extern bool NSUnLinkModule(NSModule module, uint32_t options) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-#define NSUNLINKMODULE_OPTION_NONE                  0x0
-#define NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED    0x1
-#define NSUNLINKMODULE_OPTION_RESET_LAZY_REFERENCES	0x2
-
-/* symbol API */
-typedef struct __NSSymbol* NSSymbol;
-extern bool     NSIsSymbolNameDefined(const char* symbolName)                                                    __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern bool     NSIsSymbolNameDefinedWithHint(const char* symbolName, const char* libraryNameHint)               __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern bool     NSIsSymbolNameDefinedInImage(const struct mach_header* image, const char* symbolName)            __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern NSSymbol NSLookupAndBindSymbol(const char* symbolName)                                                    __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern NSSymbol NSLookupAndBindSymbolWithHint(const char* symbolName, const char* libraryNameHint)               __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern NSSymbol NSLookupSymbolInModule(NSModule module, const char* symbolName)                                  __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlsym()");
-extern NSSymbol NSLookupSymbolInImage(const struct mach_header* image, const char* symbolName, uint32_t options) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlsym()");
-#define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND            0x0
-#define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_NOW        0x1
-#define NSLOOKUPSYMBOLINIMAGE_OPTION_BIND_FULLY      0x2
-#define NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR 0x4
-extern const char*  NSNameOfSymbol(NSSymbol symbol)    __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-extern void *       NSAddressOfSymbol(NSSymbol symbol) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlsym()");
-extern NSModule     NSModuleForSymbol(NSSymbol symbol) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dladdr()");
-
-/* error handling API */
-typedef enum {
-    NSLinkEditFileAccessError,
-    NSLinkEditFileFormatError,
-    NSLinkEditMachResourceError,
-    NSLinkEditUnixResourceError,
-    NSLinkEditOtherError,
-    NSLinkEditWarningError,
-    NSLinkEditMultiplyDefinedError,
-    NSLinkEditUndefinedError
-} NSLinkEditErrors;
-
-/*
- * For the NSLinkEditErrors value NSLinkEditOtherError these are the values
- * passed to the link edit error handler as the errorNumber (what would be an
- * errno value for NSLinkEditUnixResourceError or a kern_return_t value for
- * NSLinkEditMachResourceError).
- */
-typedef enum {
-    NSOtherErrorRelocation, 
-    NSOtherErrorLazyBind,
-    NSOtherErrorIndrLoop,
-    NSOtherErrorLazyInit,
-    NSOtherErrorInvalidArgs
-} NSOtherErrorNumbers;
-
-extern void NSLinkEditError(NSLinkEditErrors *c, int *errorNumber, const char** fileName, const char** errorString) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlerror()");
-
-typedef struct {
-     void     (*undefined)(const char* symbolName);
-     NSModule (*multiple)(NSSymbol s, NSModule oldModule, NSModule newModule); 
-     void     (*linkEdit)(NSLinkEditErrors errorClass, int errorNumber,
-                          const char* fileName, const char* errorString);
-} NSLinkEditErrorHandlers;
-
-extern void NSInstallLinkEditErrorHandlers(const NSLinkEditErrorHandlers *handlers) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "");
-
-extern bool                      NSAddLibrary(const char* pathName)                   __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlopen()");
-extern bool                      NSAddLibraryWithSearching(const char* pathName)      __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlopen()");
-extern const struct mach_header* NSAddImage(const char* image_name, uint32_t options) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlopen()");
-#define NSADDIMAGE_OPTION_NONE                  	0x0
-#define NSADDIMAGE_OPTION_RETURN_ON_ERROR       	0x1
-#define NSADDIMAGE_OPTION_WITH_SEARCHING        	0x2
-#define NSADDIMAGE_OPTION_RETURN_ONLY_IF_LOADED 	0x4
-#define NSADDIMAGE_OPTION_MATCH_FILENAME_BY_INSTALLNAME	0x8
-
-extern bool _dyld_present(void)                                                              __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "always true");
-extern bool _dyld_launched_prebound(void)                                                    __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "moot");
-extern bool _dyld_all_twolevel_modules_prebound(void)                                        __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.3, 10.5, "moot");
-extern bool _dyld_bind_fully_image_containing_address(const void* address)                   __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlopen(RTLD_NOW)");
-extern bool _dyld_image_containing_address(const void* address)                              __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.3, 10.5, "dladdr()");
-extern void _dyld_lookup_and_bind(const char* symbol_name, void **address, NSModule* module) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern void _dyld_lookup_and_bind_with_hint(const char* symbol_name, const char* library_name_hint, void** address, NSModule* module) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.4, "dlsym()");
-extern void _dyld_lookup_and_bind_fully(const char* symbol_name, void** address, NSModule* module) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.1, 10.5, "dlsym()");
-
-extern const struct mach_header*  _dyld_get_image_header_containing_address(const void* address) __API_UNAVAILABLE(ios, tvos, watchos)  DYLD_DRIVERKIT_UNAVAILABLE  __OSX_DEPRECATED(10.3, 10.5, "dladdr()");
-
-
-#if __cplusplus
-}
-#endif 
-
-#endif /* _MACH_O_DYLD_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/kern_return.h b/lib/libc/include/x86_64-macos.10-none/mach/kern_return.h
deleted file mode 100644
index 62d6415f52..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/kern_return.h
+++ /dev/null
@@ -1,330 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	File:	h/kern_return.h
- *	Author:	Avadis Tevanian, Jr.
- *	Date:	1985
- *
- *	Kernel return codes.
- *
- */
-
-#ifndef _MACH_KERN_RETURN_H_
-#define _MACH_KERN_RETURN_H_
-
-#include <mach/machine/kern_return.h>
-
-#define KERN_SUCCESS                    0
-
-#define KERN_INVALID_ADDRESS            1
-/* Specified address is not currently valid.
- */
-
-#define KERN_PROTECTION_FAILURE         2
-/* Specified memory is valid, but does not permit the
- * required forms of access.
- */
-
-#define KERN_NO_SPACE                   3
-/* The address range specified is already in use, or
- * no address range of the size specified could be
- * found.
- */
-
-#define KERN_INVALID_ARGUMENT           4
-/* The function requested was not applicable to this
- * type of argument, or an argument is invalid
- */
-
-#define KERN_FAILURE                    5
-/* The function could not be performed.  A catch-all.
- */
-
-#define KERN_RESOURCE_SHORTAGE          6
-/* A system resource could not be allocated to fulfill
- * this request.  This failure may not be permanent.
- */
-
-#define KERN_NOT_RECEIVER               7
-/* The task in question does not hold receive rights
- * for the port argument.
- */
-
-#define KERN_NO_ACCESS                  8
-/* Bogus access restriction.
- */
-
-#define KERN_MEMORY_FAILURE             9
-/* During a page fault, the target address refers to a
- * memory object that has been destroyed.  This
- * failure is permanent.
- */
-
-#define KERN_MEMORY_ERROR               10
-/* During a page fault, the memory object indicated
- * that the data could not be returned.  This failure
- * may be temporary; future attempts to access this
- * same data may succeed, as defined by the memory
- * object.
- */
-
-#define KERN_ALREADY_IN_SET             11
-/* The receive right is already a member of the portset.
- */
-
-#define KERN_NOT_IN_SET                 12
-/* The receive right is not a member of a port set.
- */
-
-#define KERN_NAME_EXISTS                13
-/* The name already denotes a right in the task.
- */
-
-#define KERN_ABORTED                    14
-/* The operation was aborted.  Ipc code will
- * catch this and reflect it as a message error.
- */
-
-#define KERN_INVALID_NAME               15
-/* The name doesn't denote a right in the task.
- */
-
-#define KERN_INVALID_TASK               16
-/* Target task isn't an active task.
- */
-
-#define KERN_INVALID_RIGHT              17
-/* The name denotes a right, but not an appropriate right.
- */
-
-#define KERN_INVALID_VALUE              18
-/* A blatant range error.
- */
-
-#define KERN_UREFS_OVERFLOW             19
-/* Operation would overflow limit on user-references.
- */
-
-#define KERN_INVALID_CAPABILITY         20
-/* The supplied (port) capability is improper.
- */
-
-#define KERN_RIGHT_EXISTS               21
-/* The task already has send or receive rights
- * for the port under another name.
- */
-
-#define KERN_INVALID_HOST               22
-/* Target host isn't actually a host.
- */
-
-#define KERN_MEMORY_PRESENT             23
-/* An attempt was made to supply "precious" data
- * for memory that is already present in a
- * memory object.
- */
-
-#define KERN_MEMORY_DATA_MOVED          24
-/* A page was requested of a memory manager via
- * memory_object_data_request for an object using
- * a MEMORY_OBJECT_COPY_CALL strategy, with the
- * VM_PROT_WANTS_COPY flag being used to specify
- * that the page desired is for a copy of the
- * object, and the memory manager has detected
- * the page was pushed into a copy of the object
- * while the kernel was walking the shadow chain
- * from the copy to the object. This error code
- * is delivered via memory_object_data_error
- * and is handled by the kernel (it forces the
- * kernel to restart the fault). It will not be
- * seen by users.
- */
-
-#define KERN_MEMORY_RESTART_COPY        25
-/* A strategic copy was attempted of an object
- * upon which a quicker copy is now possible.
- * The caller should retry the copy using
- * vm_object_copy_quickly. This error code
- * is seen only by the kernel.
- */
-
-#define KERN_INVALID_PROCESSOR_SET      26
-/* An argument applied to assert processor set privilege
- * was not a processor set control port.
- */
-
-#define KERN_POLICY_LIMIT               27
-/* The specified scheduling attributes exceed the thread's
- * limits.
- */
-
-#define KERN_INVALID_POLICY             28
-/* The specified scheduling policy is not currently
- * enabled for the processor set.
- */
-
-#define KERN_INVALID_OBJECT             29
-/* The external memory manager failed to initialize the
- * memory object.
- */
-
-#define KERN_ALREADY_WAITING            30
-/* A thread is attempting to wait for an event for which
- * there is already a waiting thread.
- */
-
-#define KERN_DEFAULT_SET                31
-/* An attempt was made to destroy the default processor
- * set.
- */
-
-#define KERN_EXCEPTION_PROTECTED        32
-/* An attempt was made to fetch an exception port that is
- * protected, or to abort a thread while processing a
- * protected exception.
- */
-
-#define KERN_INVALID_LEDGER             33
-/* A ledger was required but not supplied.
- */
-
-#define KERN_INVALID_MEMORY_CONTROL     34
-/* The port was not a memory cache control port.
- */
-
-#define KERN_INVALID_SECURITY           35
-/* An argument supplied to assert security privilege
- * was not a host security port.
- */
-
-#define KERN_NOT_DEPRESSED              36
-/* thread_depress_abort was called on a thread which
- * was not currently depressed.
- */
-
-#define KERN_TERMINATED                 37
-/* Object has been terminated and is no longer available
- */
-
-#define KERN_LOCK_SET_DESTROYED         38
-/* Lock set has been destroyed and is no longer available.
- */
-
-#define KERN_LOCK_UNSTABLE              39
-/* The thread holding the lock terminated before releasing
- * the lock
- */
-
-#define KERN_LOCK_OWNED                 40
-/* The lock is already owned by another thread
- */
-
-#define KERN_LOCK_OWNED_SELF            41
-/* The lock is already owned by the calling thread
- */
-
-#define KERN_SEMAPHORE_DESTROYED        42
-/* Semaphore has been destroyed and is no longer available.
- */
-
-#define KERN_RPC_SERVER_TERMINATED      43
-/* Return from RPC indicating the target server was
- * terminated before it successfully replied
- */
-
-#define KERN_RPC_TERMINATE_ORPHAN       44
-/* Terminate an orphaned activation.
- */
-
-#define KERN_RPC_CONTINUE_ORPHAN        45
-/* Allow an orphaned activation to continue executing.
- */
-
-#define KERN_NOT_SUPPORTED              46
-/* Empty thread activation (No thread linked to it)
- */
-
-#define KERN_NODE_DOWN                  47
-/* Remote node down or inaccessible.
- */
-
-#define KERN_NOT_WAITING                48
-/* A signalled thread was not actually waiting. */
-
-#define KERN_OPERATION_TIMED_OUT        49
-/* Some thread-oriented operation (semaphore_wait) timed out
- */
-
-#define KERN_CODESIGN_ERROR             50
-/* During a page fault, indicates that the page was rejected
- * as a result of a signature check.
- */
-
-#define KERN_POLICY_STATIC              51
-/* The requested property cannot be changed at this time.
- */
-
-#define KERN_INSUFFICIENT_BUFFER_SIZE   52
-/* The provided buffer is of insufficient size for the requested data.
- */
-
-#define KERN_RETURN_MAX                 0x100
-/* Maximum return value allowable
- */
-
-#endif  /* _MACH_KERN_RETURN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/lock_set.h b/lib/libc/include/x86_64-macos.10-none/mach/lock_set.h
deleted file mode 100644
index 752d7c2976..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/lock_set.h
+++ /dev/null
@@ -1,350 +0,0 @@
-#ifndef	_lock_set_user_
-#define	_lock_set_user_
-
-/* Module lock_set */
-
-#include <string.h>
-#include <mach/ndr.h>
-#include <mach/boolean.h>
-#include <mach/kern_return.h>
-#include <mach/notify.h>
-#include <mach/mach_types.h>
-#include <mach/message.h>
-#include <mach/mig_errors.h>
-#include <mach/port.h>
-	
-/* BEGIN MIG_STRNCPY_ZEROFILL CODE */
-
-#if defined(__has_include)
-#if __has_include(<mach/mig_strncpy_zerofill_support.h>)
-#ifndef USING_MIG_STRNCPY_ZEROFILL
-#define USING_MIG_STRNCPY_ZEROFILL
-#endif
-#ifndef __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__
-#define __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__
-#ifdef __cplusplus
-extern "C" {
-#endif
-	extern int mig_strncpy_zerofill(char *dest, const char *src, int len) __attribute__((weak_import));
-#ifdef __cplusplus
-}
-#endif
-#endif /* __MIG_STRNCPY_ZEROFILL_FORWARD_TYPE_DECLS__ */
-#endif /* __has_include(<mach/mig_strncpy_zerofill_support.h>) */
-#endif /* __has_include */
-	
-/* END MIG_STRNCPY_ZEROFILL CODE */
-
-
-#ifdef AUTOTEST
-#ifndef FUNCTION_PTR_T
-#define FUNCTION_PTR_T
-typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
-typedef struct {
-        char            *name;
-        function_ptr_t  function;
-} function_table_entry;
-typedef function_table_entry   *function_table_t;
-#endif /* FUNCTION_PTR_T */
-#endif /* AUTOTEST */
-
-#ifndef	lock_set_MSG_COUNT
-#define	lock_set_MSG_COUNT	6
-#endif	/* lock_set_MSG_COUNT */
-
-#include <mach/std_types.h>
-#include <mach/mig.h>
-#include <mach/mig.h>
-#include <mach/mach_types.h>
-
-#ifdef __BeforeMigUserHeader
-__BeforeMigUserHeader
-#endif /* __BeforeMigUserHeader */
-
-#include <sys/cdefs.h>
-__BEGIN_DECLS
-
-
-/* Routine lock_acquire */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t lock_acquire
-(
-	lock_set_t lock_set,
-	int lock_id
-);
-
-/* Routine lock_release */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t lock_release
-(
-	lock_set_t lock_set,
-	int lock_id
-);
-
-/* Routine lock_try */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t lock_try
-(
-	lock_set_t lock_set,
-	int lock_id
-);
-
-/* Routine lock_make_stable */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t lock_make_stable
-(
-	lock_set_t lock_set,
-	int lock_id
-);
-
-/* Routine lock_handoff */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t lock_handoff
-(
-	lock_set_t lock_set,
-	int lock_id
-);
-
-/* Routine lock_handoff_accept */
-#ifdef	mig_external
-mig_external
-#else
-extern
-#endif	/* mig_external */
-kern_return_t lock_handoff_accept
-(
-	lock_set_t lock_set,
-	int lock_id
-);
-
-__END_DECLS
-
-/********************** Caution **************************/
-/* The following data types should be used to calculate  */
-/* maximum message sizes only. The actual message may be */
-/* smaller, and the position of the arguments within the */
-/* message layout may vary from what is presented here.  */
-/* For example, if any of the arguments are variable-    */
-/* sized, and less than the maximum is sent, the data    */
-/* will be packed tight in the actual message to reduce  */
-/* the presence of holes.                                */
-/********************** Caution **************************/
-
-/* typedefs for all requests */
-
-#ifndef __Request__lock_set_subsystem__defined
-#define __Request__lock_set_subsystem__defined
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int lock_id;
-	} __Request__lock_acquire_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int lock_id;
-	} __Request__lock_release_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int lock_id;
-	} __Request__lock_try_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int lock_id;
-	} __Request__lock_make_stable_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int lock_id;
-	} __Request__lock_handoff_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		int lock_id;
-	} __Request__lock_handoff_accept_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-#endif /* !__Request__lock_set_subsystem__defined */
-
-/* union of all requests */
-
-#ifndef __RequestUnion__lock_set_subsystem__defined
-#define __RequestUnion__lock_set_subsystem__defined
-union __RequestUnion__lock_set_subsystem {
-	__Request__lock_acquire_t Request_lock_acquire;
-	__Request__lock_release_t Request_lock_release;
-	__Request__lock_try_t Request_lock_try;
-	__Request__lock_make_stable_t Request_lock_make_stable;
-	__Request__lock_handoff_t Request_lock_handoff;
-	__Request__lock_handoff_accept_t Request_lock_handoff_accept;
-};
-#endif /* !__RequestUnion__lock_set_subsystem__defined */
-/* typedefs for all replies */
-
-#ifndef __Reply__lock_set_subsystem__defined
-#define __Reply__lock_set_subsystem__defined
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__lock_acquire_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__lock_release_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__lock_try_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__lock_make_stable_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__lock_handoff_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-
-#ifdef  __MigPackStructs
-#pragma pack(push, 4)
-#endif
-	typedef struct {
-		mach_msg_header_t Head;
-		NDR_record_t NDR;
-		kern_return_t RetCode;
-	} __Reply__lock_handoff_accept_t __attribute__((unused));
-#ifdef  __MigPackStructs
-#pragma pack(pop)
-#endif
-#endif /* !__Reply__lock_set_subsystem__defined */
-
-/* union of all replies */
-
-#ifndef __ReplyUnion__lock_set_subsystem__defined
-#define __ReplyUnion__lock_set_subsystem__defined
-union __ReplyUnion__lock_set_subsystem {
-	__Reply__lock_acquire_t Reply_lock_acquire;
-	__Reply__lock_release_t Reply_lock_release;
-	__Reply__lock_try_t Reply_lock_try;
-	__Reply__lock_make_stable_t Reply_lock_make_stable;
-	__Reply__lock_handoff_t Reply_lock_handoff;
-	__Reply__lock_handoff_accept_t Reply_lock_handoff_accept;
-};
-#endif /* !__RequestUnion__lock_set_subsystem__defined */
-
-#ifndef subsystem_to_name_map_lock_set
-#define subsystem_to_name_map_lock_set \
-    { "lock_acquire", 617000 },\
-    { "lock_release", 617001 },\
-    { "lock_try", 617002 },\
-    { "lock_make_stable", 617003 },\
-    { "lock_handoff", 617004 },\
-    { "lock_handoff_accept", 617005 }
-#endif
-
-#ifdef __AfterMigUserHeader
-__AfterMigUserHeader
-#endif /* __AfterMigUserHeader */
-
-#endif	 /* _lock_set_user_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/mach_init.h b/lib/libc/include/x86_64-macos.10-none/mach/mach_init.h
deleted file mode 100644
index d61d6e90b5..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/mach_init.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/*
- * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987,1986 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-
-/*
- *	Items provided by the Mach environment initialization.
- */
-
-#ifndef _MACH_INIT_
-#define _MACH_INIT_     1
-
-#include <mach/mach_types.h>
-#include <mach/vm_page_size.h>
-#include <stdarg.h>
-
-#include <sys/cdefs.h>
-
-/*
- *	Kernel-related ports; how a task/thread controls itself
- */
-
-__BEGIN_DECLS
-extern mach_port_t mach_host_self(void);
-extern mach_port_t mach_thread_self(void);
-extern kern_return_t host_page_size(host_t, vm_size_t *);
-
-extern mach_port_t      mach_task_self_;
-#define mach_task_self() mach_task_self_
-#define current_task()  mach_task_self()
-
-__END_DECLS
-#include <mach/mach_traps.h>
-__BEGIN_DECLS
-
-/*
- *	Other important ports in the Mach user environment
- */
-
-extern  mach_port_t     bootstrap_port;
-
-/*
- *	Where these ports occur in the "mach_ports_register"
- *	collection... only servers or the runtime library need know.
- */
-
-#define NAME_SERVER_SLOT        0
-#define ENVIRONMENT_SLOT        1
-#define SERVICE_SLOT            2
-
-#define MACH_PORTS_SLOTS_USED   3
-
-/*
- *	fprintf_stderr uses vprintf_stderr_func to produce
- *	error messages, this can be overridden by a user
- *	application to point to a user-specified output function
- */
-extern int (*vprintf_stderr_func)(const char *format, va_list ap);
-
-__END_DECLS
-
-#endif  /* _MACH_INIT_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/mach_traps.h b/lib/libc/include/x86_64-macos.10-none/mach/mach_traps.h
deleted file mode 100644
index d3aaf577ed..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/mach_traps.h
+++ /dev/null
@@ -1,303 +0,0 @@
-/*
- * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	Definitions of general Mach system traps.
- *
- *	These are the definitions as seen from user-space.
- *	The kernel definitions are in <mach/syscall_sw.h>.
- *	Kernel RPC functions are defined in <mach/mach_interface.h>.
- */
-
-#ifndef _MACH_MACH_TRAPS_H_
-#define _MACH_MACH_TRAPS_H_
-
-#include <stdint.h>
-
-#include <mach/std_types.h>
-#include <mach/mach_types.h>
-#include <mach/kern_return.h>
-#include <mach/port.h>
-#include <mach/vm_types.h>
-#include <mach/clock_types.h>
-
-#include <machine/endian.h>
-
-#include <sys/cdefs.h>
-
-__BEGIN_DECLS
-
-
-
-extern kern_return_t clock_sleep_trap(
-	mach_port_name_t clock_name,
-	sleep_type_t sleep_type,
-	int sleep_sec,
-	int sleep_nsec,
-	mach_timespec_t *wakeup_time);
-
-extern kern_return_t _kernelrpc_mach_vm_allocate_trap(
-	mach_port_name_t target,
-	mach_vm_offset_t *addr,
-	mach_vm_size_t size,
-	int flags);
-
-extern kern_return_t _kernelrpc_mach_vm_deallocate_trap(
-	mach_port_name_t target,
-	mach_vm_address_t address,
-	mach_vm_size_t size
-	);
-
-extern kern_return_t _kernelrpc_mach_vm_protect_trap(
-	mach_port_name_t target,
-	mach_vm_address_t address,
-	mach_vm_size_t size,
-	boolean_t set_maximum,
-	vm_prot_t new_protection
-	);
-
-extern kern_return_t _kernelrpc_mach_vm_map_trap(
-	mach_port_name_t target,
-	mach_vm_offset_t *address,
-	mach_vm_size_t size,
-	mach_vm_offset_t mask,
-	int flags,
-	vm_prot_t cur_protection
-	);
-
-extern kern_return_t _kernelrpc_mach_vm_purgable_control_trap(
-	mach_port_name_t target,
-	mach_vm_offset_t address,
-	vm_purgable_t control,
-	int *state);
-
-extern kern_return_t _kernelrpc_mach_port_allocate_trap(
-	mach_port_name_t target,
-	mach_port_right_t right,
-	mach_port_name_t *name
-	);
-
-
-extern kern_return_t _kernelrpc_mach_port_destroy_trap(
-	mach_port_name_t target,
-	mach_port_name_t name
-	);
-
-extern kern_return_t _kernelrpc_mach_port_deallocate_trap(
-	mach_port_name_t target,
-	mach_port_name_t name
-	);
-
-extern kern_return_t _kernelrpc_mach_port_mod_refs_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	mach_port_right_t right,
-	mach_port_delta_t delta
-	);
-
-extern kern_return_t _kernelrpc_mach_port_move_member_trap(
-	mach_port_name_t target,
-	mach_port_name_t member,
-	mach_port_name_t after
-	);
-
-extern kern_return_t _kernelrpc_mach_port_insert_right_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	mach_port_name_t poly,
-	mach_msg_type_name_t polyPoly
-	);
-
-extern kern_return_t _kernelrpc_mach_port_get_attributes_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	mach_port_flavor_t flavor,
-	mach_port_info_t port_info_out,
-	mach_msg_type_number_t *port_info_outCnt
-	);
-
-extern kern_return_t _kernelrpc_mach_port_insert_member_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	mach_port_name_t pset
-	);
-
-extern kern_return_t _kernelrpc_mach_port_extract_member_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	mach_port_name_t pset
-	);
-
-extern kern_return_t _kernelrpc_mach_port_construct_trap(
-	mach_port_name_t target,
-	mach_port_options_t *options,
-	uint64_t context,
-	mach_port_name_t *name
-	);
-
-extern kern_return_t _kernelrpc_mach_port_destruct_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	mach_port_delta_t srdelta,
-	uint64_t guard
-	);
-
-extern kern_return_t _kernelrpc_mach_port_guard_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	uint64_t guard,
-	boolean_t strict
-	);
-
-extern kern_return_t _kernelrpc_mach_port_unguard_trap(
-	mach_port_name_t target,
-	mach_port_name_t name,
-	uint64_t guard
-	);
-
-extern kern_return_t mach_generate_activity_id(
-	mach_port_name_t target,
-	int count,
-	uint64_t *activity_id
-	);
-
-extern kern_return_t macx_swapon(
-	uint64_t filename,
-	int flags,
-	int size,
-	int priority);
-
-extern kern_return_t macx_swapoff(
-	uint64_t filename,
-	int flags);
-
-extern kern_return_t macx_triggers(
-	int hi_water,
-	int low_water,
-	int flags,
-	mach_port_t alert_port);
-
-extern kern_return_t macx_backing_store_suspend(
-	boolean_t suspend);
-
-extern kern_return_t macx_backing_store_recovery(
-	int pid);
-
-extern boolean_t swtch_pri(int pri);
-
-extern boolean_t swtch(void);
-
-extern kern_return_t thread_switch(
-	mach_port_name_t thread_name,
-	int option,
-	mach_msg_timeout_t option_time);
-
-extern mach_port_name_t task_self_trap(void);
-
-extern kern_return_t host_create_mach_voucher_trap(
-	mach_port_name_t host,
-	mach_voucher_attr_raw_recipe_array_t recipes,
-	int recipes_size,
-	mach_port_name_t *voucher);
-
-extern kern_return_t mach_voucher_extract_attr_recipe_trap(
-	mach_port_name_t voucher_name,
-	mach_voucher_attr_key_t key,
-	mach_voucher_attr_raw_recipe_t recipe,
-	mach_msg_type_number_t *recipe_size);
-
-extern kern_return_t _kernelrpc_mach_port_type_trap(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_port_type_t *ptype);
-
-extern kern_return_t _kernelrpc_mach_port_request_notification_trap(
-	ipc_space_t task,
-	mach_port_name_t name,
-	mach_msg_id_t msgid,
-	mach_port_mscount_t sync,
-	mach_port_name_t notify,
-	mach_msg_type_name_t notifyPoly,
-	mach_port_name_t *previous);
-
-/*
- *	Obsolete interfaces.
- */
-
-extern kern_return_t task_for_pid(
-	mach_port_name_t target_tport,
-	int pid,
-	mach_port_name_t *t);
-
-extern kern_return_t task_name_for_pid(
-	mach_port_name_t target_tport,
-	int pid,
-	mach_port_name_t *tn);
-
-extern kern_return_t pid_for_task(
-	mach_port_name_t t,
-	int *x);
-
-extern kern_return_t debug_control_port_for_pid(
-	mach_port_name_t target_tport,
-	int pid,
-	mach_port_name_t *t);
-
-
-__END_DECLS
-
-#endif  /* _MACH_MACH_TRAPS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/machine/_structs.h b/lib/libc/include/x86_64-macos.10-none/mach/machine/_structs.h
deleted file mode 100644
index 0a61125417..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/machine/_structs.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2017 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE__STRUCTS_H_
-#define _MACH_MACHINE__STRUCTS_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/_structs.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE__STRUCTS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/machine/boolean.h b/lib/libc/include/x86_64-macos.10-none/mach/machine/boolean.h
deleted file mode 100644
index d373913b40..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/machine/boolean.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_BOOLEAN_H_
-#define _MACH_MACHINE_BOOLEAN_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/boolean.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_BOOLEAN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/machine/exception.h b/lib/libc/include/x86_64-macos.10-none/mach/machine/exception.h
deleted file mode 100644
index f3e960d436..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/machine/exception.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_EXCEPTION_H_
-#define _MACH_MACHINE_EXCEPTION_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/exception.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_EXCEPTION_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/machine/kern_return.h b/lib/libc/include/x86_64-macos.10-none/mach/machine/kern_return.h
deleted file mode 100644
index b764492d29..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/machine/kern_return.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_KERN_RETURN_H_
-#define _MACH_MACHINE_KERN_RETURN_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/kern_return.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_KERN_RETURN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/machine/processor_info.h b/lib/libc/include/x86_64-macos.10-none/mach/machine/processor_info.h
deleted file mode 100644
index 4e5028d24d..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/machine/processor_info.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_PROCESSOR_INFO_H_
-#define _MACH_MACHINE_PROCESSOR_INFO_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/processor_info.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_PROCESSOR_INFO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/machine/thread_state.h b/lib/libc/include/x86_64-macos.10-none/mach/machine/thread_state.h
deleted file mode 100644
index 91daad8671..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/machine/thread_state.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_THREAD_STATE_H_
-#define _MACH_MACHINE_THREAD_STATE_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/thread_state.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_THREAD_STATE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/machine/thread_status.h b/lib/libc/include/x86_64-macos.10-none/mach/machine/thread_status.h
deleted file mode 100644
index 7e65df246e..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/machine/thread_status.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_THREAD_STATUS_H_
-#define _MACH_MACHINE_THREAD_STATUS_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/thread_status.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_THREAD_STATUS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/machine/vm_param.h b/lib/libc/include/x86_64-macos.10-none/mach/machine/vm_param.h
deleted file mode 100644
index 7f272f5b70..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/machine/vm_param.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_VM_PARAM_H_
-#define _MACH_MACHINE_VM_PARAM_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/vm_param.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_VM_PARAM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/machine/vm_types.h b/lib/libc/include/x86_64-macos.10-none/mach/machine/vm_types.h
deleted file mode 100644
index 5d16a871ea..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/machine/vm_types.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_MACHINE_VM_TYPES_H_
-#define _MACH_MACHINE_VM_TYPES_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "mach/i386/vm_types.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _MACH_MACHINE_VM_TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/memory_object_types.h b/lib/libc/include/x86_64-macos.10-none/mach/memory_object_types.h
deleted file mode 100644
index fec6e53593..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/memory_object_types.h
+++ /dev/null
@@ -1,299 +0,0 @@
-/*
- * Copyright (c) 2000-2016 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	File:	memory_object.h
- *	Author:	Michael Wayne Young
- *
- *	External memory management interface definition.
- */
-
-#ifndef _MACH_MEMORY_OBJECT_TYPES_H_
-#define _MACH_MEMORY_OBJECT_TYPES_H_
-
-/*
- *	User-visible types used in the external memory
- *	management interface:
- */
-
-#include <mach/port.h>
-#include <mach/message.h>
-#include <mach/vm_prot.h>
-#include <mach/vm_sync.h>
-#include <mach/vm_types.h>
-#include <mach/machine/vm_types.h>
-
-#include <sys/cdefs.h>
-
-#define VM_64_BIT_DATA_OBJECTS
-
-typedef unsigned long long      memory_object_offset_t;
-typedef unsigned long long      memory_object_size_t;
-typedef natural_t               memory_object_cluster_size_t;
-typedef natural_t *             memory_object_fault_info_t;
-
-typedef unsigned long long      vm_object_id_t;
-
-
-/*
- * Temporary until real EMMI version gets re-implemented
- */
-
-
-typedef mach_port_t     memory_object_t;
-typedef mach_port_t     memory_object_control_t;
-
-
-typedef memory_object_t *memory_object_array_t;
-/* A memory object ... */
-/*  Used by the kernel to retrieve */
-/*  or store data */
-
-typedef mach_port_t     memory_object_name_t;
-/* Used to describe the memory ... */
-/*  object in vm_regions() calls */
-
-typedef mach_port_t     memory_object_default_t;
-/* Registered with the host ... */
-/*  for creating new internal objects */
-
-#define MEMORY_OBJECT_NULL              ((memory_object_t) 0)
-#define MEMORY_OBJECT_CONTROL_NULL      ((memory_object_control_t) 0)
-#define MEMORY_OBJECT_NAME_NULL         ((memory_object_name_t) 0)
-#define MEMORY_OBJECT_DEFAULT_NULL      ((memory_object_default_t) 0)
-
-
-typedef int             memory_object_copy_strategy_t;
-/* How memory manager handles copy: */
-#define         MEMORY_OBJECT_COPY_NONE         0
-/* ... No special support */
-#define         MEMORY_OBJECT_COPY_CALL         1
-/* ... Make call on memory manager */
-#define         MEMORY_OBJECT_COPY_DELAY        2
-/* ... Memory manager doesn't
- *     change data externally.
- */
-#define         MEMORY_OBJECT_COPY_TEMPORARY    3
-/* ... Memory manager doesn't
- *     change data externally, and
- *     doesn't need to see changes.
- */
-#define         MEMORY_OBJECT_COPY_SYMMETRIC    4
-/* ... Memory manager doesn't
- *     change data externally,
- *     doesn't need to see changes,
- *     and object will not be
- *     multiply mapped.
- *
- *     XXX
- *     Not yet safe for non-kernel use.
- */
-
-#define         MEMORY_OBJECT_COPY_INVALID      5
-/* ...	An invalid copy strategy,
- *	for external objects which
- *	have not been initialized.
- *	Allows copy_strategy to be
- *	examined without also
- *	examining pager_ready and
- *	internal.
- */
-
-typedef int             memory_object_return_t;
-/* Which pages to return to manager
- *  this time (lock_request) */
-#define         MEMORY_OBJECT_RETURN_NONE       0
-/* ... don't return any. */
-#define         MEMORY_OBJECT_RETURN_DIRTY      1
-/* ... only dirty pages. */
-#define         MEMORY_OBJECT_RETURN_ALL        2
-/* ... dirty and precious pages. */
-#define         MEMORY_OBJECT_RETURN_ANYTHING   3
-/* ... any resident page. */
-
-/*
- *	Data lock request flags
- */
-
-#define         MEMORY_OBJECT_DATA_FLUSH        0x1
-#define         MEMORY_OBJECT_DATA_NO_CHANGE    0x2
-#define         MEMORY_OBJECT_DATA_PURGE        0x4
-#define         MEMORY_OBJECT_COPY_SYNC         0x8
-#define         MEMORY_OBJECT_DATA_SYNC         0x10
-#define         MEMORY_OBJECT_IO_SYNC           0x20
-#define         MEMORY_OBJECT_DATA_FLUSH_ALL    0x40
-
-/*
- *	Types for the memory object flavor interfaces
- */
-
-#define MEMORY_OBJECT_INFO_MAX      (1024)
-typedef int     *memory_object_info_t;
-typedef int      memory_object_flavor_t;
-typedef int      memory_object_info_data_t[MEMORY_OBJECT_INFO_MAX];
-
-
-#define MEMORY_OBJECT_PERFORMANCE_INFO  11
-#define MEMORY_OBJECT_ATTRIBUTE_INFO    14
-#define MEMORY_OBJECT_BEHAVIOR_INFO     15
-
-
-struct memory_object_perf_info {
-	memory_object_cluster_size_t    cluster_size;
-	boolean_t                       may_cache;
-};
-
-struct memory_object_attr_info {
-	memory_object_copy_strategy_t   copy_strategy;
-	memory_object_cluster_size_t    cluster_size;
-	boolean_t                       may_cache_object;
-	boolean_t                       temporary;
-};
-
-struct memory_object_behave_info {
-	memory_object_copy_strategy_t   copy_strategy;
-	boolean_t                       temporary;
-	boolean_t                       invalidate;
-	boolean_t                       silent_overwrite;
-	boolean_t                       advisory_pageout;
-};
-
-
-typedef struct memory_object_behave_info *memory_object_behave_info_t;
-typedef struct memory_object_behave_info memory_object_behave_info_data_t;
-
-typedef struct memory_object_perf_info  *memory_object_perf_info_t;
-typedef struct memory_object_perf_info  memory_object_perf_info_data_t;
-
-typedef struct memory_object_attr_info  *memory_object_attr_info_t;
-typedef struct memory_object_attr_info  memory_object_attr_info_data_t;
-
-#define MEMORY_OBJECT_BEHAVE_INFO_COUNT ((mach_msg_type_number_t)       \
-	        (sizeof(memory_object_behave_info_data_t)/sizeof(int)))
-#define MEMORY_OBJECT_PERF_INFO_COUNT   ((mach_msg_type_number_t)       \
-	        (sizeof(memory_object_perf_info_data_t)/sizeof(int)))
-#define MEMORY_OBJECT_ATTR_INFO_COUNT   ((mach_msg_type_number_t)       \
-	        (sizeof(memory_object_attr_info_data_t)/sizeof(int)))
-
-#define invalid_memory_object_flavor(f)                                 \
-	(f != MEMORY_OBJECT_ATTRIBUTE_INFO &&                           \
-	 f != MEMORY_OBJECT_PERFORMANCE_INFO &&                         \
-	 f != OLD_MEMORY_OBJECT_BEHAVIOR_INFO &&                        \
-	 f != MEMORY_OBJECT_BEHAVIOR_INFO &&                            \
-	 f != OLD_MEMORY_OBJECT_ATTRIBUTE_INFO)
-
-
-/*
- * Used to support options on memory_object_release_name call
- */
-#define MEMORY_OBJECT_TERMINATE_IDLE    0x1
-#define MEMORY_OBJECT_RESPECT_CACHE     0x2
-#define MEMORY_OBJECT_RELEASE_NO_OP     0x4
-
-
-/* named entry processor mapping options */
-/* enumerated */
-#define MAP_MEM_NOOP                      0
-#define MAP_MEM_COPYBACK                  1
-#define MAP_MEM_IO                        2
-#define MAP_MEM_WTHRU                     3
-#define MAP_MEM_WCOMB                     4       /* Write combining mode */
-                                                  /* aka store gather     */
-#define MAP_MEM_INNERWBACK                5
-#define MAP_MEM_POSTED                    6
-#define MAP_MEM_RT                        7
-#define MAP_MEM_POSTED_REORDERED          8
-#define MAP_MEM_POSTED_COMBINED_REORDERED 9
-
-#define GET_MAP_MEM(flags)      \
-	((((unsigned int)(flags)) >> 24) & 0xFF)
-
-#define SET_MAP_MEM(caching, flags)     \
-	((flags) = ((((unsigned int)(caching)) << 24) \
-	                & 0xFF000000) | ((flags) & 0xFFFFFF));
-
-/* leave room for vm_prot bits (0xFF ?) */
-#define MAP_MEM_LEDGER_TAGGED        0x002000 /* object owned by a specific task and ledger */
-#define MAP_MEM_PURGABLE_KERNEL_ONLY 0x004000 /* volatility controlled by kernel */
-#define MAP_MEM_GRAB_SECLUDED   0x008000 /* can grab secluded pages */
-#define MAP_MEM_ONLY            0x010000 /* change processor caching  */
-#define MAP_MEM_NAMED_CREATE    0x020000 /* create extant object      */
-#define MAP_MEM_PURGABLE        0x040000 /* create a purgable VM object */
-#define MAP_MEM_NAMED_REUSE     0x080000 /* reuse provided entry if identical */
-#define MAP_MEM_USE_DATA_ADDR   0x100000 /* preserve address of data, rather than base of page */
-#define MAP_MEM_VM_COPY         0x200000 /* make a copy of a VM range */
-#define MAP_MEM_VM_SHARE        0x400000 /* extract a VM range for remap */
-#define MAP_MEM_4K_DATA_ADDR    0x800000 /* preserve 4K aligned address of data */
-
-#define MAP_MEM_FLAGS_MASK 0x00FFFF00
-#define MAP_MEM_FLAGS_USER (                               \
-	MAP_MEM_PURGABLE_KERNEL_ONLY |                     \
-	MAP_MEM_GRAB_SECLUDED |                            \
-	MAP_MEM_ONLY |                                     \
-	MAP_MEM_NAMED_CREATE |                             \
-	MAP_MEM_PURGABLE |                                 \
-	MAP_MEM_NAMED_REUSE |                              \
-	MAP_MEM_USE_DATA_ADDR |                            \
-	MAP_MEM_VM_COPY |                                  \
-	MAP_MEM_VM_SHARE |                                 \
-	MAP_MEM_LEDGER_TAGGED |                            \
-	MAP_MEM_4K_DATA_ADDR)
-#define MAP_MEM_FLAGS_ALL (                     \
-	MAP_MEM_FLAGS_USER)
-
-
-#endif  /* _MACH_MEMORY_OBJECT_TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/mig.h b/lib/libc/include/x86_64-macos.10-none/mach/mig.h
deleted file mode 100644
index aa7bcf7448..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/mig.h
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-
-/*
- * Mach MIG Subsystem Interfaces
- */
-
-#ifndef _MACH_MIG_H_
-#define _MACH_MIG_H_
-
-#include <stdint.h>
-#include <mach/port.h>
-#include <mach/message.h>
-#include <mach/vm_types.h>
-
-#include <sys/cdefs.h>
-
-#if defined(MACH_KERNEL)
-
-#if !defined(__MigTypeCheck)
-/* Turn MIG type checking on by default for kernel */
-#define __MigTypeCheck 1
-#endif
-
-#define __MigKernelSpecificCode 1
-#define _MIG_KERNEL_SPECIFIC_CODE_ 1
-
-#elif !defined(__MigTypeCheck)
-
-#if defined(TypeCheck)
-/* use legacy setting (temporary) */
-#define __MigTypeCheck TypeCheck
-#else
-/* default MIG type checking on */
-#define __MigTypeCheck 1
-#endif
-
-#endif /* !defined(MACH_KERNEL) && !defined(__MigTypeCheck) */
-
-/*
- * Pack MIG message structs.
- * This is an indicator of the need to view shared structs in a
- * binary-compatible format - and MIG message structs are no different.
- */
-#define __MigPackStructs 1
-
-/*
- * Definition for MIG-generated server stub routines.  These routines
- * unpack the request message, call the server procedure, and pack the
- * reply message.
- */
-typedef void    (*mig_stub_routine_t) (mach_msg_header_t *InHeadP,
-    mach_msg_header_t *OutHeadP);
-
-typedef mig_stub_routine_t mig_routine_t;
-
-/*
- * Definition for MIG-generated server routine.  This routine takes a
- * message, and returns the appropriate stub function for handling that
- * message.
- */
-typedef mig_routine_t (*mig_server_routine_t) (mach_msg_header_t *InHeadP);
-
-/*
- * Generic definition for implementation routines.  These routines do
- * the real work associated with this request.  This generic type is
- * used for keeping the pointers in the subsystem array.
- */
-typedef kern_return_t   (*mig_impl_routine_t)(void);
-
-typedef mach_msg_type_descriptor_t routine_arg_descriptor;
-typedef mach_msg_type_descriptor_t *routine_arg_descriptor_t;
-typedef mach_msg_type_descriptor_t *mig_routine_arg_descriptor_t;
-
-#define MIG_ROUTINE_ARG_DESCRIPTOR_NULL ((mig_routine_arg_descriptor_t)0)
-
-struct routine_descriptor {
-	mig_impl_routine_t      impl_routine;   /* Server work func pointer   */
-	mig_stub_routine_t      stub_routine;   /* Unmarshalling func pointer */
-	unsigned int            argc;                   /* Number of argument words   */
-	unsigned int            descr_count;    /* Number complex descriptors */
-	routine_arg_descriptor_t
-	    arg_descr;                                                  /* pointer to descriptor array*/
-	unsigned int            max_reply_msg;  /* Max size for reply msg     */
-};
-typedef struct routine_descriptor *routine_descriptor_t;
-
-typedef struct routine_descriptor mig_routine_descriptor;
-typedef mig_routine_descriptor *mig_routine_descriptor_t;
-
-#define MIG_ROUTINE_DESCRIPTOR_NULL ((mig_routine_descriptor_t)0)
-
-typedef struct mig_subsystem {
-	mig_server_routine_t server;            /* pointer to demux routine	*/
-	mach_msg_id_t            start;                 /* Min routine number	    */
-	mach_msg_id_t            end;                   /* Max routine number + 1   */
-	mach_msg_size_t          maxsize;               /* Max reply message size   */
-	vm_address_t             reserved;              /* reserved for MIG use	    */
-	mig_routine_descriptor
-	    routine[1];                                         /* Routine descriptor array */
-} *mig_subsystem_t;
-
-#define MIG_SUBSYSTEM_NULL              ((mig_subsystem_t)0)
-
-typedef struct mig_symtab {
-	char                            *ms_routine_name;
-	int                                     ms_routine_number;
-	void                            (*ms_routine)(void);    /* Since the functions in the
-	                                                         * symbol table have unknown
-	                                                         * signatures, this is the best
-	                                                         * we can do...
-	                                                         */
-} mig_symtab_t;
-
-/*
- * A compiler attribute for annotating all MIG server routines and other
- * functions that should behave similarly.  Allows the compiler to perform
- * additional static bug-finding over them.
- */
-#if __has_attribute(mig_server_routine)
-#define MIG_SERVER_ROUTINE __attribute__((mig_server_routine))
-#else
-#define MIG_SERVER_ROUTINE
-#endif
-
-
-__BEGIN_DECLS
-
-/* Client side reply port allocate */
-extern mach_port_t mig_get_reply_port(void);
-
-/* Client side reply port deallocate */
-extern void mig_dealloc_reply_port(mach_port_t reply_port);
-
-/* Client side reply port "deallocation" */
-extern void mig_put_reply_port(mach_port_t reply_port);
-
-/* Bounded string copy */
-extern int mig_strncpy(char     *dest, const char *src, int     len);
-extern int mig_strncpy_zerofill(char    *dest, const char *src, int     len);
-
-
-/* Allocate memory for out-of-line mig structures */
-extern void mig_allocate(vm_address_t *, vm_size_t);
-
-/* Deallocate memory used for out-of-line mig structures */
-extern void mig_deallocate(vm_address_t, vm_size_t);
-
-
-__END_DECLS
-
-#endif  /* _MACH_MIG_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/task_info.h b/lib/libc/include/x86_64-macos.10-none/mach/task_info.h
deleted file mode 100644
index 5b2046a700..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/task_info.h
+++ /dev/null
@@ -1,478 +0,0 @@
-/*
- * Copyright (c) 2000-2007, 2015 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- *	Machine-independent task information structures and definitions.
- *
- *	The definitions in this file are exported to the user.  The kernel
- *	will translate its internal data structures to these structures
- *	as appropriate.
- *
- */
-
-#ifndef _MACH_TASK_INFO_H_
-#define _MACH_TASK_INFO_H_
-
-#include <mach/message.h>
-#include <mach/machine/vm_types.h>
-#include <mach/time_value.h>
-#include <mach/policy.h>
-#include <mach/vm_statistics.h> /* for vm_extmod_statistics_data_t */
-#include <Availability.h>
-
-#include <sys/cdefs.h>
-
-/*
- *	Generic information structure to allow for expansion.
- */
-typedef natural_t       task_flavor_t;
-typedef integer_t       *task_info_t;           /* varying array of int */
-
-/* Deprecated, use per structure _data_t's instead */
-#define TASK_INFO_MAX   (1024)          /* maximum array size */
-typedef integer_t       task_info_data_t[TASK_INFO_MAX];
-
-/*
- *	Currently defined information structures.
- */
-
-#pragma pack(push, 4)
-
-/* Don't use this, use MACH_TASK_BASIC_INFO instead */
-#define TASK_BASIC_INFO_32      4       /* basic information */
-#define TASK_BASIC2_INFO_32      6
-
-struct task_basic_info_32 {
-	integer_t       suspend_count;  /* suspend count for task */
-	natural_t       virtual_size;   /* virtual memory size (bytes) */
-	natural_t       resident_size;  /* resident memory size (bytes) */
-	time_value_t    user_time;      /* total user run time for
-	                                 *  terminated threads */
-	time_value_t    system_time;    /* total system run time for
-	                                 *  terminated threads */
-	policy_t        policy;         /* default policy for new threads */
-};
-typedef struct task_basic_info_32       task_basic_info_32_data_t;
-typedef struct task_basic_info_32       *task_basic_info_32_t;
-#define TASK_BASIC_INFO_32_COUNT   \
-	        (sizeof(task_basic_info_32_data_t) / sizeof(natural_t))
-
-/* Don't use this, use MACH_TASK_BASIC_INFO instead */
-struct task_basic_info_64 {
-	integer_t       suspend_count;  /* suspend count for task */
-	mach_vm_size_t  virtual_size;   /* virtual memory size (bytes) */
-	mach_vm_size_t  resident_size;  /* resident memory size (bytes) */
-	time_value_t    user_time;      /* total user run time for
-	                                 *  terminated threads */
-	time_value_t    system_time;    /* total system run time for
-	                                 *  terminated threads */
-	policy_t        policy;         /* default policy for new threads */
-};
-typedef struct task_basic_info_64       task_basic_info_64_data_t;
-typedef struct task_basic_info_64       *task_basic_info_64_t;
-
-#define TASK_BASIC_INFO_64      5       /* 64-bit capable basic info */
-#define TASK_BASIC_INFO_64_COUNT   \
-	        (sizeof(task_basic_info_64_data_t) / sizeof(natural_t))
-
-
-/* localized structure - cannot be safely passed between tasks of differing sizes */
-/* Don't use this, use MACH_TASK_BASIC_INFO instead */
-struct task_basic_info {
-	integer_t       suspend_count;  /* suspend count for task */
-	vm_size_t       virtual_size;   /* virtual memory size (bytes) */
-	vm_size_t       resident_size;  /* resident memory size (bytes) */
-	time_value_t    user_time;      /* total user run time for
-	                                 *  terminated threads */
-	time_value_t    system_time;    /* total system run time for
-	                                 *  terminated threads */
-	policy_t        policy;         /* default policy for new threads */
-};
-
-typedef struct task_basic_info          task_basic_info_data_t;
-typedef struct task_basic_info          *task_basic_info_t;
-#define TASK_BASIC_INFO_COUNT   \
-	        (sizeof(task_basic_info_data_t) / sizeof(natural_t))
-#if !defined(__LP64__)
-#define TASK_BASIC_INFO TASK_BASIC_INFO_32
-#else
-#define TASK_BASIC_INFO TASK_BASIC_INFO_64
-#endif
-
-
-
-#define TASK_EVENTS_INFO        2       /* various event counts */
-
-struct task_events_info {
-	integer_t       faults;         /* number of page faults */
-	integer_t       pageins;        /* number of actual pageins */
-	integer_t       cow_faults;     /* number of copy-on-write faults */
-	integer_t       messages_sent;  /* number of messages sent */
-	integer_t       messages_received; /* number of messages received */
-	integer_t       syscalls_mach;  /* number of mach system calls */
-	integer_t       syscalls_unix;  /* number of unix system calls */
-	integer_t       csw;            /* number of context switches */
-};
-typedef struct task_events_info         task_events_info_data_t;
-typedef struct task_events_info         *task_events_info_t;
-#define TASK_EVENTS_INFO_COUNT          ((mach_msg_type_number_t) \
-	        (sizeof(task_events_info_data_t) / sizeof(natural_t)))
-
-#define TASK_THREAD_TIMES_INFO  3       /* total times for live threads -
-	                                 *  only accurate if suspended */
-
-struct task_thread_times_info {
-	time_value_t    user_time;      /* total user run time for
-	                                 *  live threads */
-	time_value_t    system_time;    /* total system run time for
-	                                 *  live threads */
-};
-
-typedef struct task_thread_times_info   task_thread_times_info_data_t;
-typedef struct task_thread_times_info   *task_thread_times_info_t;
-#define TASK_THREAD_TIMES_INFO_COUNT    ((mach_msg_type_number_t) \
-	        (sizeof(task_thread_times_info_data_t) / sizeof(natural_t)))
-
-#define TASK_ABSOLUTETIME_INFO  1
-
-struct task_absolutetime_info {
-	uint64_t                total_user;
-	uint64_t                total_system;
-	uint64_t                threads_user;   /* existing threads only */
-	uint64_t                threads_system;
-};
-
-typedef struct task_absolutetime_info   task_absolutetime_info_data_t;
-typedef struct task_absolutetime_info   *task_absolutetime_info_t;
-#define TASK_ABSOLUTETIME_INFO_COUNT    ((mach_msg_type_number_t) \
-	        (sizeof (task_absolutetime_info_data_t) / sizeof (natural_t)))
-
-#define TASK_KERNELMEMORY_INFO  7
-
-struct task_kernelmemory_info {
-	uint64_t                total_palloc;   /* private kernel mem alloc'ed */
-	uint64_t                total_pfree;    /* private kernel mem freed */
-	uint64_t                total_salloc;   /* shared kernel mem alloc'ed */
-	uint64_t                total_sfree;    /* shared kernel mem freed */
-};
-
-typedef struct task_kernelmemory_info   task_kernelmemory_info_data_t;
-typedef struct task_kernelmemory_info   *task_kernelmemory_info_t;
-#define TASK_KERNELMEMORY_INFO_COUNT    ((mach_msg_type_number_t) \
-	        (sizeof (task_kernelmemory_info_data_t) / sizeof (natural_t)))
-
-#define TASK_SECURITY_TOKEN             13
-#define TASK_SECURITY_TOKEN_COUNT       ((mach_msg_type_number_t) \
-	        (sizeof(security_token_t) / sizeof(natural_t)))
-
-#define TASK_AUDIT_TOKEN                15
-#define TASK_AUDIT_TOKEN_COUNT  \
-	        (sizeof(audit_token_t) / sizeof(natural_t))
-
-
-#define TASK_AFFINITY_TAG_INFO          16      /* This is experimental. */
-
-struct task_affinity_tag_info {
-	integer_t               set_count;
-	integer_t               min;
-	integer_t               max;
-	integer_t               task_count;
-};
-typedef struct task_affinity_tag_info   task_affinity_tag_info_data_t;
-typedef struct task_affinity_tag_info   *task_affinity_tag_info_t;
-#define TASK_AFFINITY_TAG_INFO_COUNT    \
-	        (sizeof(task_affinity_tag_info_data_t) / sizeof(natural_t))
-
-#define TASK_DYLD_INFO                  17
-
-struct task_dyld_info {
-	mach_vm_address_t       all_image_info_addr;
-	mach_vm_size_t          all_image_info_size;
-	integer_t               all_image_info_format;
-};
-typedef struct task_dyld_info   task_dyld_info_data_t;
-typedef struct task_dyld_info   *task_dyld_info_t;
-#define TASK_DYLD_INFO_COUNT    \
-	        (sizeof(task_dyld_info_data_t) / sizeof(natural_t))
-#define TASK_DYLD_ALL_IMAGE_INFO_32     0       /* format value */
-#define TASK_DYLD_ALL_IMAGE_INFO_64     1       /* format value */
-
-
-#define TASK_EXTMOD_INFO                        19
-
-struct task_extmod_info {
-	unsigned char   task_uuid[16];
-	vm_extmod_statistics_data_t             extmod_statistics;
-};
-typedef struct task_extmod_info task_extmod_info_data_t;
-typedef struct task_extmod_info *task_extmod_info_t;
-#define TASK_EXTMOD_INFO_COUNT  \
-	        (sizeof(task_extmod_info_data_t) / sizeof(natural_t))
-
-
-#define MACH_TASK_BASIC_INFO     20         /* always 64-bit basic info */
-struct mach_task_basic_info {
-	mach_vm_size_t  virtual_size;       /* virtual memory size (bytes) */
-	mach_vm_size_t  resident_size;      /* resident memory size (bytes) */
-	mach_vm_size_t  resident_size_max;  /* maximum resident memory size (bytes) */
-	time_value_t    user_time;          /* total user run time for
-	                                     *  terminated threads */
-	time_value_t    system_time;        /* total system run time for
-	                                     *  terminated threads */
-	policy_t        policy;             /* default policy for new threads */
-	integer_t       suspend_count;      /* suspend count for task */
-};
-typedef struct mach_task_basic_info       mach_task_basic_info_data_t;
-typedef struct mach_task_basic_info       *mach_task_basic_info_t;
-#define MACH_TASK_BASIC_INFO_COUNT   \
-	        (sizeof(mach_task_basic_info_data_t) / sizeof(natural_t))
-
-
-#define TASK_POWER_INFO 21
-
-struct task_power_info {
-	uint64_t                total_user;
-	uint64_t                total_system;
-	uint64_t                task_interrupt_wakeups;
-	uint64_t                task_platform_idle_wakeups;
-	uint64_t                task_timer_wakeups_bin_1;
-	uint64_t                task_timer_wakeups_bin_2;
-};
-
-typedef struct task_power_info  task_power_info_data_t;
-typedef struct task_power_info  *task_power_info_t;
-#define TASK_POWER_INFO_COUNT   ((mach_msg_type_number_t) \
-	        (sizeof (task_power_info_data_t) / sizeof (natural_t)))
-
-
-
-#define TASK_VM_INFO            22
-#define TASK_VM_INFO_PURGEABLE  23
-struct task_vm_info {
-	mach_vm_size_t  virtual_size;       /* virtual memory size (bytes) */
-	integer_t       region_count;       /* number of memory regions */
-	integer_t       page_size;
-	mach_vm_size_t  resident_size;      /* resident memory size (bytes) */
-	mach_vm_size_t  resident_size_peak; /* peak resident size (bytes) */
-
-	mach_vm_size_t  device;
-	mach_vm_size_t  device_peak;
-	mach_vm_size_t  internal;
-	mach_vm_size_t  internal_peak;
-	mach_vm_size_t  external;
-	mach_vm_size_t  external_peak;
-	mach_vm_size_t  reusable;
-	mach_vm_size_t  reusable_peak;
-	mach_vm_size_t  purgeable_volatile_pmap;
-	mach_vm_size_t  purgeable_volatile_resident;
-	mach_vm_size_t  purgeable_volatile_virtual;
-	mach_vm_size_t  compressed;
-	mach_vm_size_t  compressed_peak;
-	mach_vm_size_t  compressed_lifetime;
-
-	/* added for rev1 */
-	mach_vm_size_t  phys_footprint;
-
-	/* added for rev2 */
-	mach_vm_address_t       min_address;
-	mach_vm_address_t       max_address;
-
-	/* added for rev3 */
-	int64_t ledger_phys_footprint_peak;
-	int64_t ledger_purgeable_nonvolatile;
-	int64_t ledger_purgeable_novolatile_compressed;
-	int64_t ledger_purgeable_volatile;
-	int64_t ledger_purgeable_volatile_compressed;
-	int64_t ledger_tag_network_nonvolatile;
-	int64_t ledger_tag_network_nonvolatile_compressed;
-	int64_t ledger_tag_network_volatile;
-	int64_t ledger_tag_network_volatile_compressed;
-	int64_t ledger_tag_media_footprint;
-	int64_t ledger_tag_media_footprint_compressed;
-	int64_t ledger_tag_media_nofootprint;
-	int64_t ledger_tag_media_nofootprint_compressed;
-	int64_t ledger_tag_graphics_footprint;
-	int64_t ledger_tag_graphics_footprint_compressed;
-	int64_t ledger_tag_graphics_nofootprint;
-	int64_t ledger_tag_graphics_nofootprint_compressed;
-	int64_t ledger_tag_neural_footprint;
-	int64_t ledger_tag_neural_footprint_compressed;
-	int64_t ledger_tag_neural_nofootprint;
-	int64_t ledger_tag_neural_nofootprint_compressed;
-
-	/* added for rev4 */
-	uint64_t limit_bytes_remaining;
-
-	/* added for rev5 */
-	integer_t decompressions;
-};
-typedef struct task_vm_info     task_vm_info_data_t;
-typedef struct task_vm_info     *task_vm_info_t;
-#define TASK_VM_INFO_COUNT      ((mach_msg_type_number_t) \
-	        (sizeof (task_vm_info_data_t) / sizeof (natural_t)))
-#define TASK_VM_INFO_REV5_COUNT TASK_VM_INFO_COUNT
-#define TASK_VM_INFO_REV4_COUNT /* doesn't include decompressions */ \
-	((mach_msg_type_number_t) (TASK_VM_INFO_REV5_COUNT - 1))
-#define TASK_VM_INFO_REV3_COUNT /* doesn't include limit bytes */ \
-	((mach_msg_type_number_t) (TASK_VM_INFO_REV4_COUNT - 2))
-#define TASK_VM_INFO_REV2_COUNT /* doesn't include extra ledgers info */ \
-	((mach_msg_type_number_t) (TASK_VM_INFO_REV3_COUNT - 42))
-#define TASK_VM_INFO_REV1_COUNT /* doesn't include min and max address */ \
-	((mach_msg_type_number_t) (TASK_VM_INFO_REV2_COUNT - 4))
-#define TASK_VM_INFO_REV0_COUNT /* doesn't include phys_footprint */ \
-	((mach_msg_type_number_t) (TASK_VM_INFO_REV1_COUNT - 2))
-
-typedef struct vm_purgeable_info        task_purgable_info_t;
-
-
-#define TASK_TRACE_MEMORY_INFO  24
-struct task_trace_memory_info {
-	uint64_t  user_memory_address;  /* address of start of trace memory buffer */
-	uint64_t  buffer_size;                  /* size of buffer in bytes */
-	uint64_t  mailbox_array_size;   /* size of mailbox area in bytes */
-};
-typedef struct task_trace_memory_info task_trace_memory_info_data_t;
-typedef struct task_trace_memory_info * task_trace_memory_info_t;
-#define TASK_TRACE_MEMORY_INFO_COUNT  ((mach_msg_type_number_t) \
-	        (sizeof(task_trace_memory_info_data_t) / sizeof(natural_t)))
-
-#define TASK_WAIT_STATE_INFO  25    /* deprecated. */
-struct task_wait_state_info {
-	uint64_t  total_wait_state_time;        /* Time that all threads past and present have been in a wait state */
-	uint64_t  total_wait_sfi_state_time;    /* Time that threads have been in SFI wait (should be a subset of total wait state time */
-	uint32_t  _reserved[4];
-};
-typedef struct task_wait_state_info task_wait_state_info_data_t;
-typedef struct task_wait_state_info * task_wait_state_info_t;
-#define TASK_WAIT_STATE_INFO_COUNT  ((mach_msg_type_number_t) \
-	        (sizeof(task_wait_state_info_data_t) / sizeof(natural_t)))
-
-#define TASK_POWER_INFO_V2      26
-
-typedef struct {
-	uint64_t                task_gpu_utilisation;
-	uint64_t                task_gpu_stat_reserved0;
-	uint64_t                task_gpu_stat_reserved1;
-	uint64_t                task_gpu_stat_reserved2;
-} gpu_energy_data;
-
-typedef gpu_energy_data *gpu_energy_data_t;
-struct task_power_info_v2 {
-	task_power_info_data_t  cpu_energy;
-	gpu_energy_data gpu_energy;
-	uint64_t                task_ptime;
-	uint64_t                task_pset_switches;
-};
-
-typedef struct task_power_info_v2       task_power_info_v2_data_t;
-typedef struct task_power_info_v2       *task_power_info_v2_t;
-#define TASK_POWER_INFO_V2_COUNT_OLD    \
-	        ((mach_msg_type_number_t) (sizeof (task_power_info_v2_data_t) - sizeof(uint64_t)*2) / sizeof (natural_t))
-#define TASK_POWER_INFO_V2_COUNT        \
-	        ((mach_msg_type_number_t) (sizeof (task_power_info_v2_data_t) / sizeof (natural_t)))
-
-#define TASK_VM_INFO_PURGEABLE_ACCOUNT 27 /* Used for xnu purgeable vm unit tests */
-
-
-#define TASK_FLAGS_INFO  28                     /* return t_flags field */
-struct task_flags_info {
-	uint32_t        flags;                          /* task flags */
-};
-typedef struct task_flags_info task_flags_info_data_t;
-typedef struct task_flags_info * task_flags_info_t;
-#define TASK_FLAGS_INFO_COUNT  ((mach_msg_type_number_t) \
-	        (sizeof(task_flags_info_data_t) / sizeof (natural_t)))
-
-#define TF_LP64         0x00000001 /* task has 64-bit addressing */
-#define TF_64B_DATA     0x00000002 /* task has 64-bit data registers */
-
-#define TASK_DEBUG_INFO_INTERNAL    29 /* Used for kernel internal development tests. */
-
-
-/*
- * Type to control EXC_GUARD delivery options for a task
- * via task_get/set_exc_guard_behavior interface(s).
- */
-typedef uint32_t task_exc_guard_behavior_t;
-
-/* EXC_GUARD optional delivery settings on a per-task basis */
-#define TASK_EXC_GUARD_VM_DELIVER            0x01 /* Deliver virtual memory EXC_GUARD exceptions */
-#define TASK_EXC_GUARD_VM_ONCE               0x02 /* Deliver them only once */
-#define TASK_EXC_GUARD_VM_CORPSE             0x04 /* Deliver them via a forked corpse */
-#define TASK_EXC_GUARD_VM_FATAL              0x08 /* Virtual Memory EXC_GUARD delivery is fatal */
-#define TASK_EXC_GUARD_VM_ALL                0x0f
-
-#define TASK_EXC_GUARD_MP_DELIVER            0x10 /* Deliver mach port EXC_GUARD exceptions */
-#define TASK_EXC_GUARD_MP_ONCE               0x20 /* Deliver them only once */
-#define TASK_EXC_GUARD_MP_CORPSE             0x40 /* Deliver them via a forked corpse */
-#define TASK_EXC_GUARD_MP_FATAL              0x80 /* mach port EXC_GUARD delivery is fatal */
-#define TASK_EXC_GUARD_MP_ALL                0xf0
-
-#define TASK_EXC_GUARD_ALL                   0xff /* All optional deliver settings */
-
-
-/*
- * Obsolete interfaces.
- */
-
-#define TASK_SCHED_TIMESHARE_INFO       10
-#define TASK_SCHED_RR_INFO              11
-#define TASK_SCHED_FIFO_INFO            12
-
-#define TASK_SCHED_INFO                 14
-
-#pragma pack(pop)
-
-#endif  /* _MACH_TASK_INFO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/task_inspect.h b/lib/libc/include/x86_64-macos.10-none/mach/task_inspect.h
deleted file mode 100644
index 1ae3c6e5f1..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/task_inspect.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2017 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef MACH_TASK_INSPECT_H
-#define MACH_TASK_INSPECT_H
-
-/*
- * XXX These interfaces are still in development -- they are subject to change
- * without notice.
- */
-
-typedef natural_t task_inspect_flavor_t;
-
-enum task_inspect_flavor {
-	TASK_INSPECT_BASIC_COUNTS = 1,
-};
-
-struct task_inspect_basic_counts {
-	uint64_t instructions;
-	uint64_t cycles;
-};
-#define TASK_INSPECT_BASIC_COUNTS_COUNT \
-	(sizeof(struct task_inspect_basic_counts) / sizeof(natural_t))
-typedef struct task_inspect_basic_counts task_inspect_basic_counts_data_t;
-typedef struct task_inspect_basic_counts *task_inspect_basic_counts_t;
-
-typedef integer_t *task_inspect_info_t;
-
-#endif /* !defined(MACH_TASK_INSPECT_H) */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/task_special_ports.h b/lib/libc/include/x86_64-macos.10-none/mach/task_special_ports.h
deleted file mode 100644
index f8ee7c2bbf..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/task_special_ports.h
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * Copyright (c) 2000-2010 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	File:	mach/task_special_ports.h
- *
- *	Defines codes for special_purpose task ports.  These are NOT
- *	port identifiers - they are only used for the task_get_special_port
- *	and task_set_special_port routines.
- *
- */
-
-#ifndef _MACH_TASK_SPECIAL_PORTS_H_
-#define _MACH_TASK_SPECIAL_PORTS_H_
-
-typedef int     task_special_port_t;
-
-#define TASK_KERNEL_PORT        1       /* Represents task to the outside
-	                                 *  world.*/
-
-#define TASK_HOST_PORT          2       /* The host (priv) port for task.  */
-
-#define TASK_NAME_PORT          3       /* the name (unpriv) port for task */
-
-#define TASK_BOOTSTRAP_PORT     4       /* Bootstrap environment for task. */
-
-/*
- * Evolving and likely to change.
- */
-
-#define TASK_SEATBELT_PORT      7       /* Seatbelt compiler/DEM port for task. */
-
-/* PORT 8 was the GSSD TASK PORT which transformed to a host port */
-
-#define TASK_ACCESS_PORT        9       /* Permission check for task_for_pid. */
-
-#define TASK_DEBUG_CONTROL_PORT 10      /* debug control port */
-
-#define TASK_RESOURCE_NOTIFY_PORT   11  /* overrides host special RN port */
-
-#define TASK_MAX_SPECIAL_PORT TASK_RESOURCE_NOTIFY_PORT
-
-/*
- *	Definitions for ease of use
- */
-
-#define task_get_kernel_port(task, port)        \
-	        (task_get_special_port((task), TASK_KERNEL_PORT, (port)))
-
-#define task_set_kernel_port(task, port)        \
-	        (task_set_special_port((task), TASK_KERNEL_PORT, (port)))
-
-#define task_get_host_port(task, port)          \
-	        (task_get_special_port((task), TASK_HOST_PORT, (port)))
-
-#define task_set_host_port(task, port)  \
-	        (task_set_special_port((task), TASK_HOST_PORT, (port)))
-
-#define task_get_bootstrap_port(task, port)     \
-	        (task_get_special_port((task), TASK_BOOTSTRAP_PORT, (port)))
-
-#define task_get_debug_control_port(task, port) \
-	        (task_get_special_port((task), TASK_DEBUG_CONTROL_PORT, (port)))
-
-#define task_set_bootstrap_port(task, port)     \
-	        (task_set_special_port((task), TASK_BOOTSTRAP_PORT, (port)))
-
-#define task_get_task_access_port(task, port)   \
-	        (task_get_special_port((task), TASK_ACCESS_PORT, (port)))
-
-#define task_set_task_access_port(task, port)   \
-	        (task_set_special_port((task), TASK_ACCESS_PORT, (port)))
-
-#define task_set_task_debug_control_port(task, port) \
-	        (task_set_special_port((task), TASK_DEBUG_CONTROL_PORT, (port)))
-
-
-#endif  /* _MACH_TASK_SPECIAL_PORTS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/thread_state.h b/lib/libc/include/x86_64-macos.10-none/mach/thread_state.h
deleted file mode 100644
index 33b38b8665..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/thread_state.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * Copyright (c) 2015 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _MACH_THREAD_STATE_H_
-#define _MACH_THREAD_STATE_H_
-
-#include <Availability.h>
-#include <mach/mach.h>
-
-#ifndef KERNEL
-/*
- * Gets all register values in the target thread with pointer-like contents.
- *
- * There is no guarantee that the returned values are valid pointers, but all
- * valid pointers will be returned.  The order and count of the provided
- * register values is unspecified and may change; registers with values that
- * are not valid pointers may be omitted, so the number of pointers returned
- * may vary from call to call.
- *
- * sp is an out parameter that will contain the stack pointer.
- * length is an in/out parameter for the length of the values array.
- * values is an array of pointers.
- *
- * This may only be called on threads in the current task.  If the current
- * platform defines a stack red zone, the stack pointer returned will be
- * adjusted to account for red zone.
- *
- * If length is insufficient, KERN_INSUFFICIENT_BUFFER_SIZE will be returned
- * and length set to the amount of memory required.  Callers MUST NOT assume
- * that any particular size of buffer will be sufficient and should retry with
- * an appropriately sized buffer upon this error.
- */
-__API_AVAILABLE(macosx(10.14), ios(12.0), tvos(9.0), watchos(5.0))
-kern_return_t thread_get_register_pointer_values(thread_t thread,
-    uintptr_t *sp, size_t *length, uintptr_t *values);
-#endif
-
-#endif /* _MACH_THREAD_STATE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/thread_status.h b/lib/libc/include/x86_64-macos.10-none/mach/thread_status.h
deleted file mode 100644
index 886cae365c..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach/thread_status.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	File:	mach/thread_status.h
- *	Author:	Avadis Tevanian, Jr.
- *
- *	This file contains the structure definitions for the user-visible
- *	thread state.  This thread state is examined with the thread_get_state
- *	kernel call and may be changed with the thread_set_state kernel call.
- *
- */
-
-#ifndef _MACH_THREAD_STATUS_H_
-#define _MACH_THREAD_STATUS_H_
-
-/*
- *	The actual structure that comprises the thread state is defined
- *	in the machine dependent module.
- */
-#include <mach/machine/vm_types.h>
-#include <mach/machine/thread_status.h>
-#include <mach/machine/thread_state.h>
-
-/*
- *	Generic definition for machine-dependent thread status.
- */
-
-typedef natural_t       *thread_state_t;        /* Variable-length array */
-
-/* THREAD_STATE_MAX is now defined in <mach/machine/thread_state.h> */
-typedef natural_t       thread_state_data_t[THREAD_STATE_MAX];
-
-#define THREAD_STATE_FLAVOR_LIST        0       /* List of valid flavors */
-#define THREAD_STATE_FLAVOR_LIST_NEW    128
-#define THREAD_STATE_FLAVOR_LIST_10_9   129
-#define THREAD_STATE_FLAVOR_LIST_10_13  130
-#define THREAD_STATE_FLAVOR_LIST_10_15  131
-
-typedef int                     thread_state_flavor_t;
-typedef thread_state_flavor_t   *thread_state_flavor_array_t;
-
-#endif  /* _MACH_THREAD_STATUS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach_debug/mach_debug_types.h b/lib/libc/include/x86_64-macos.10-none/mach_debug/mach_debug_types.h
deleted file mode 100644
index a4a2f3d7c7..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/mach_debug/mach_debug_types.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * @OSF_COPYRIGHT@
- */
-/*
- * Mach Operating System
- * Copyright (c) 1991,1990,1989,1988 Carnegie Mellon University
- * All Rights Reserved.
- *
- * Permission to use, copy, modify and distribute this software and its
- * documentation is hereby granted, provided that both the copyright
- * notice and this permission notice appear in all copies of the
- * software, derivative works or modified versions, and any portions
- * thereof, and that both notices appear in supporting documentation.
- *
- * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
- * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
- * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
- *
- * Carnegie Mellon requests users of this software to return to
- *
- *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
- *  School of Computer Science
- *  Carnegie Mellon University
- *  Pittsburgh PA 15213-3890
- *
- * any improvements or extensions that they make and grant Carnegie Mellon
- * the rights to redistribute these changes.
- */
-/*
- */
-/*
- *	Mach kernel debugging interface type declarations
- */
-
-#ifndef _MACH_DEBUG_MACH_DEBUG_TYPES_H_
-#define _MACH_DEBUG_MACH_DEBUG_TYPES_H_
-
-#include <mach_debug/ipc_info.h>
-#include <mach_debug/vm_info.h>
-#include <mach_debug/zone_info.h>
-#include <mach_debug/page_info.h>
-#include <mach_debug/hash_info.h>
-#include <mach_debug/lockgroup_info.h>
-
-#define MACH_CORE_FILEHEADER_SIGNATURE  0x0063614d20646152ULL
-#define MACH_CORE_FILEHEADER_MAXFILES 16
-#define MACH_CORE_FILEHEADER_NAMELEN 16
-
-typedef char    symtab_name_t[32];
-
-struct mach_core_details {
-	uint64_t gzip_offset;
-	uint64_t gzip_length;
-	char core_name[MACH_CORE_FILEHEADER_NAMELEN];
-};
-
-struct mach_core_fileheader {
-	uint64_t signature;
-	uint64_t log_offset;
-	uint64_t log_length;
-	uint64_t num_files;
-	struct mach_core_details files[MACH_CORE_FILEHEADER_MAXFILES];
-};
-
-#define KOBJECT_DESCRIPTION_LENGTH      512
-typedef char kobject_description_t[KOBJECT_DESCRIPTION_LENGTH];
-
-#endif  /* _MACH_DEBUG_MACH_DEBUG_TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/machine/_mcontext.h b/lib/libc/include/x86_64-macos.10-none/machine/_mcontext.h
deleted file mode 100644
index 9ccd985fcc..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/machine/_mcontext.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#if defined (__i386__) || defined (__x86_64__)
-#include "i386/_mcontext.h"
-#else
-#error architecture not supported
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/machine/_param.h b/lib/libc/include/x86_64-macos.10-none/machine/_param.h
deleted file mode 100644
index c40232c3c2..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/machine/_param.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2004-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#if defined (__i386__) || defined (__x86_64__)
-#include "i386/_param.h"
-#else
-#error architecture not supported
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/machine/_types.h b/lib/libc/include/x86_64-macos.10-none/machine/_types.h
deleted file mode 100644
index 0ed6acf677..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/machine/_types.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2003-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _BSD_MACHINE__TYPES_H_
-#define _BSD_MACHINE__TYPES_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "i386/_types.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _BSD_MACHINE__TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/machine/endian.h b/lib/libc/include/x86_64-macos.10-none/machine/endian.h
deleted file mode 100644
index 85c8f12508..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/machine/endian.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Copyright 1995 NeXT Computer, Inc. All rights reserved.
- */
-#ifndef _BSD_MACHINE_ENDIAN_H_
-#define _BSD_MACHINE_ENDIAN_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "i386/endian.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _BSD_MACHINE_ENDIAN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/machine/limits.h b/lib/libc/include/x86_64-macos.10-none/machine/limits.h
deleted file mode 100644
index 9763e810b6..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/machine/limits.h
+++ /dev/null
@@ -1,9 +0,0 @@
-/* This is the `system' limits.h, independent of any particular
- *  compiler.  GCC provides its own limits.h which can be found in
- *  /usr/lib/gcc, although it is not very informative.
- *  This file is public domain.  */
-#if defined (__i386__) || defined(__x86_64__)
-#include <i386/limits.h>
-#else
-#error architecture not supported
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/machine/param.h b/lib/libc/include/x86_64-macos.10-none/machine/param.h
deleted file mode 100644
index 8435acbdfb..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/machine/param.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Copyright 1995 NeXT Computer, Inc. All rights reserved.
- */
-#ifndef _BSD_MACHINE_PARAM_H_
-#define _BSD_MACHINE_PARAM_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "i386/param.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _BSD_MACHINE_PARAM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/machine/signal.h b/lib/libc/include/x86_64-macos.10-none/machine/signal.h
deleted file mode 100644
index 19ef535ebd..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/machine/signal.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _BSD_MACHINE_SIGNAL_H_
-#define _BSD_MACHINE_SIGNAL_H_
-
-#if defined (__i386__) || defined(__x86_64__)
-#include "i386/signal.h"
-#else
-#error architecture not supported
-#endif
-
-#endif /* _BSD_MACHINE_SIGNAL_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/malloc/_malloc.h b/lib/libc/include/x86_64-macos.10-none/malloc/_malloc.h
deleted file mode 100644
index 91555d11bb..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/malloc/_malloc.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2018 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _MALLOC_UNDERSCORE_MALLOC_H_
-#define _MALLOC_UNDERSCORE_MALLOC_H_
-
-/*
- * This header is included from <stdlib.h>, so the contents of this file have
- * broad source compatibility and POSIX conformance implications.
- * Be cautious about what is included and declared here.
- */
-
-#include <Availability.h>
-#include <sys/cdefs.h>
-#include <_types.h>
-#include <sys/_types/_size_t.h>
-
-__BEGIN_DECLS
-
-void	*malloc(size_t __size) __result_use_check __alloc_size(1);
-void	*calloc(size_t __count, size_t __size) __result_use_check __alloc_size(1,2);
-void	 free(void *);
-void	*realloc(void *__ptr, size_t __size) __result_use_check __alloc_size(2);
-#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
-void	*valloc(size_t) __alloc_size(1);
-#endif // !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
-#if (__DARWIN_C_LEVEL >= __DARWIN_C_FULL) && \
-        ((defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || \
-         (defined(__cplusplus) && __cplusplus >= 201703L))
-void    *aligned_alloc(size_t __alignment, size_t __size) __result_use_check __alloc_size(2) __OSX_AVAILABLE(10.15) __IOS_AVAILABLE(13.0) __TVOS_AVAILABLE(13.0) __WATCHOS_AVAILABLE(6.0);
-#endif
-int 	 posix_memalign(void **__memptr, size_t __alignment, size_t __size) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_0);
-
-__END_DECLS
-
-#endif /* _MALLOC_UNDERSCORE_MALLOC_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/math.h b/lib/libc/include/x86_64-macos.10-none/math.h
deleted file mode 100644
index 8bb019247e..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/math.h
+++ /dev/null
@@ -1,771 +0,0 @@
-/*
- * Copyright (c) 2002-2017 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
- * 
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef __MATH_H__
-#define __MATH_H__
-
-#ifndef __MATH__
-#define __MATH__
-#endif
-
-#include <sys/cdefs.h>
-#include <Availability.h>
-
-__BEGIN_DECLS
-
-/******************************************************************************
- * Floating point data types                                                  *
- ******************************************************************************/
-
-/*  Define float_t and double_t per C standard, ISO/IEC 9899:2011 7.12 2,
-    taking advantage of GCC's __FLT_EVAL_METHOD__ (which a compiler may
-    define anytime and GCC does) that shadows FLT_EVAL_METHOD (which a
-    compiler must define only in float.h).                                    */
-#if __FLT_EVAL_METHOD__ == 0
-    typedef float float_t;
-    typedef double double_t;
-#elif __FLT_EVAL_METHOD__ == 1
-    typedef double float_t;
-    typedef double double_t;
-#elif __FLT_EVAL_METHOD__ == 2 || __FLT_EVAL_METHOD__ == -1
-    typedef long double float_t;
-    typedef long double double_t;
-#else /* __FLT_EVAL_METHOD__ */
-#   error "Unsupported value of __FLT_EVAL_METHOD__."
-#endif /* __FLT_EVAL_METHOD__ */
-
-#if defined(__GNUC__)
-#   define    HUGE_VAL     __builtin_huge_val()
-#   define    HUGE_VALF    __builtin_huge_valf()
-#   define    HUGE_VALL    __builtin_huge_vall()
-#   define    NAN          __builtin_nanf("0x7fc00000")
-#else
-#   define    HUGE_VAL     1e500
-#   define    HUGE_VALF    1e50f
-#   define    HUGE_VALL    1e5000L
-#   define    NAN          __nan()
-#endif
-
-#define INFINITY    HUGE_VALF
-
-/******************************************************************************
- *      Taxonomy of floating point data types                                 *
- ******************************************************************************/
-
-#define FP_NAN          1
-#define FP_INFINITE     2
-#define FP_ZERO         3
-#define FP_NORMAL       4
-#define FP_SUBNORMAL    5
-#define FP_SUPERNORMAL  6 /* legacy PowerPC support; this is otherwise unused */
-
-#if defined __arm64__ || defined __ARM_VFPV4__
-/*  On these architectures, fma(), fmaf( ), and fmal( ) are generally about as
-    fast as (or faster than) separate multiply and add of the same operands.  */
-#   define FP_FAST_FMA     1
-#   define FP_FAST_FMAF    1
-#   define FP_FAST_FMAL    1
-#elif (defined __i386__ || defined __x86_64__) && (defined __FMA__ || defined __AVX512F__)
-/*  When targeting the FMA ISA extension, fma() and fmaf( ) are generally
-    about as fast as (or faster than) separate multiply and add of the same
-    operands, but fmal( ) may be more costly.                                 */
-#   define FP_FAST_FMA     1
-#   define FP_FAST_FMAF    1
-#   undef  FP_FAST_FMAL
-#else
-/*  On these architectures, fma( ), fmaf( ), and fmal( ) function calls are
-    significantly more costly than separate multiply and add operations.      */
-#   undef  FP_FAST_FMA
-#   undef  FP_FAST_FMAF
-#   undef  FP_FAST_FMAL
-#endif
-
-/* The values returned by `ilogb' for 0 and NaN respectively. */
-#define FP_ILOGB0      (-2147483647 - 1)
-#define FP_ILOGBNAN    (-2147483647 - 1)
-
-/* Bitmasks for the math_errhandling macro.  */
-#define MATH_ERRNO        1    /* errno set by math functions.  */
-#define MATH_ERREXCEPT    2    /* Exceptions raised by math functions.  */
-
-#define math_errhandling (__math_errhandling())
-extern int __math_errhandling(void);
-
-/******************************************************************************
- *                                                                            *
- *                              Inquiry macros                                *
- *                                                                            *
- *  fpclassify      Returns one of the FP_* values.                           *
- *  isnormal        Non-zero if and only if the argument x is normalized.     *
- *  isfinite        Non-zero if and only if the argument x is finite.         *
- *  isnan           Non-zero if and only if the argument x is a NaN.          *
- *  signbit         Non-zero if and only if the sign of the argument x is     *
- *                  negative.  This includes, NaNs, infinities and zeros.     *
- *                                                                            *
- ******************************************************************************/
-
-#define fpclassify(x)                                                    \
-    ( sizeof(x) == sizeof(float)  ? __fpclassifyf((float)(x))            \
-    : sizeof(x) == sizeof(double) ? __fpclassifyd((double)(x))           \
-                                  : __fpclassifyl((long double)(x)))
-
-extern int __fpclassifyf(float);
-extern int __fpclassifyd(double);
-extern int __fpclassifyl(long double);
-
-#if (defined(__GNUC__) && 0 == __FINITE_MATH_ONLY__)
-/*  These inline functions may fail to return expected results if unsafe
-    math optimizations like those enabled by -ffast-math are turned on.
-    Thus, (somewhat surprisingly) you only get the fast inline
-    implementations if such compiler options are NOT enabled.  This is
-    because the inline functions require the compiler to be adhering to
-    the standard in order to work properly; -ffast-math, among other
-    things, implies that NaNs don't happen, which allows the compiler to
-    optimize away checks like x != x, which might lead to things like
-    isnan(NaN) returning false.                                               
- 
-    Thus, if you compile with -ffast-math, actual function calls are
-    generated for these utilities.                                            */
-    
-#define isnormal(x)                                                      \
-    ( sizeof(x) == sizeof(float)  ? __inline_isnormalf((float)(x))       \
-    : sizeof(x) == sizeof(double) ? __inline_isnormald((double)(x))      \
-                                  : __inline_isnormall((long double)(x)))
-
-#define isfinite(x)                                                      \
-    ( sizeof(x) == sizeof(float)  ? __inline_isfinitef((float)(x))       \
-    : sizeof(x) == sizeof(double) ? __inline_isfinited((double)(x))      \
-                                  : __inline_isfinitel((long double)(x)))
-
-#define isinf(x)                                                         \
-    ( sizeof(x) == sizeof(float)  ? __inline_isinff((float)(x))          \
-    : sizeof(x) == sizeof(double) ? __inline_isinfd((double)(x))         \
-                                  : __inline_isinfl((long double)(x)))
-
-#define isnan(x)                                                         \
-    ( sizeof(x) == sizeof(float)  ? __inline_isnanf((float)(x))          \
-    : sizeof(x) == sizeof(double) ? __inline_isnand((double)(x))         \
-                                  : __inline_isnanl((long double)(x)))
-
-#define signbit(x)                                                       \
-    ( sizeof(x) == sizeof(float)  ? __inline_signbitf((float)(x))        \
-    : sizeof(x) == sizeof(double) ? __inline_signbitd((double)(x))       \
-                                  : __inline_signbitl((long double)(x)))
-
-__header_always_inline int __inline_isfinitef(float);
-__header_always_inline int __inline_isfinited(double);
-__header_always_inline int __inline_isfinitel(long double);
-__header_always_inline int __inline_isinff(float);
-__header_always_inline int __inline_isinfd(double);
-__header_always_inline int __inline_isinfl(long double);
-__header_always_inline int __inline_isnanf(float);
-__header_always_inline int __inline_isnand(double);
-__header_always_inline int __inline_isnanl(long double);
-__header_always_inline int __inline_isnormalf(float);
-__header_always_inline int __inline_isnormald(double);
-__header_always_inline int __inline_isnormall(long double);
-__header_always_inline int __inline_signbitf(float);
-__header_always_inline int __inline_signbitd(double);
-__header_always_inline int __inline_signbitl(long double);
-    
-__header_always_inline int __inline_isfinitef(float __x) {
-    return __x == __x && __builtin_fabsf(__x) != __builtin_inff();
-}
-__header_always_inline int __inline_isfinited(double __x) {
-    return __x == __x && __builtin_fabs(__x) != __builtin_inf();
-}
-__header_always_inline int __inline_isfinitel(long double __x) {
-    return __x == __x && __builtin_fabsl(__x) != __builtin_infl();
-}
-__header_always_inline int __inline_isinff(float __x) {
-    return __builtin_fabsf(__x) == __builtin_inff();
-}
-__header_always_inline int __inline_isinfd(double __x) {
-    return __builtin_fabs(__x) == __builtin_inf();
-}
-__header_always_inline int __inline_isinfl(long double __x) {
-    return __builtin_fabsl(__x) == __builtin_infl();
-}
-__header_always_inline int __inline_isnanf(float __x) {
-    return __x != __x;
-}
-__header_always_inline int __inline_isnand(double __x) {
-    return __x != __x;
-}
-__header_always_inline int __inline_isnanl(long double __x) {
-    return __x != __x;
-}
-__header_always_inline int __inline_signbitf(float __x) {
-    union { float __f; unsigned int __u; } __u;
-    __u.__f = __x;
-    return (int)(__u.__u >> 31);
-}
-__header_always_inline int __inline_signbitd(double __x) {
-    union { double __f; unsigned long long __u; } __u;
-    __u.__f = __x;
-    return (int)(__u.__u >> 63);
-}
-#if defined __i386__ || defined __x86_64__
-__header_always_inline int __inline_signbitl(long double __x) {
-    union {
-        long double __ld;
-        struct{ unsigned long long __m; unsigned short __sexp; } __p;
-    } __u;
-    __u.__ld = __x;
-    return (int)(__u.__p.__sexp >> 15);
-}
-#else
-__header_always_inline int __inline_signbitl(long double __x) {
-    union { long double __f; unsigned long long __u;} __u;
-    __u.__f = __x;
-    return (int)(__u.__u >> 63);
-}
-#endif
-__header_always_inline int __inline_isnormalf(float __x) {
-    return __inline_isfinitef(__x) && __builtin_fabsf(__x) >= __FLT_MIN__;
-}
-__header_always_inline int __inline_isnormald(double __x) {
-    return __inline_isfinited(__x) && __builtin_fabs(__x) >= __DBL_MIN__;
-}
-__header_always_inline int __inline_isnormall(long double __x) {
-    return __inline_isfinitel(__x) && __builtin_fabsl(__x) >= __LDBL_MIN__;
-}
-    
-#else /* defined(__GNUC__) && 0 == __FINITE_MATH_ONLY__ */
-
-/*  Implementations making function calls to fall back on when -ffast-math
-    or similar is specified.  These are not available in iOS versions prior
-    to 6.0.  If you need them, you must target that version or later.         */
-    
-#define isnormal(x)                                               \
-    ( sizeof(x) == sizeof(float)  ? __isnormalf((float)(x))       \
-    : sizeof(x) == sizeof(double) ? __isnormald((double)(x))      \
-                                  : __isnormall((long double)(x)))
-    
-#define isfinite(x)                                               \
-    ( sizeof(x) == sizeof(float)  ? __isfinitef((float)(x))       \
-    : sizeof(x) == sizeof(double) ? __isfinited((double)(x))      \
-                                  : __isfinitel((long double)(x)))
-    
-#define isinf(x)                                                  \
-    ( sizeof(x) == sizeof(float)  ? __isinff((float)(x))          \
-    : sizeof(x) == sizeof(double) ? __isinfd((double)(x))         \
-                                  : __isinfl((long double)(x)))
-    
-#define isnan(x)                                                  \
-    ( sizeof(x) == sizeof(float)  ? __isnanf((float)(x))          \
-    : sizeof(x) == sizeof(double) ? __isnand((double)(x))         \
-                                  : __isnanl((long double)(x)))
-    
-#define signbit(x)                                                \
-    ( sizeof(x) == sizeof(float)  ? __signbitf((float)(x))        \
-    : sizeof(x) == sizeof(double) ? __signbitd((double)(x))       \
-                                  : __signbitl((long double)(x)))
-    
-extern int __isnormalf(float);
-extern int __isnormald(double);
-extern int __isnormall(long double);
-extern int __isfinitef(float);
-extern int __isfinited(double);
-extern int __isfinitel(long double);
-extern int __isinff(float);
-extern int __isinfd(double);
-extern int __isinfl(long double);
-extern int __isnanf(float);
-extern int __isnand(double);
-extern int __isnanl(long double);
-extern int __signbitf(float);
-extern int __signbitd(double);
-extern int __signbitl(long double);
-
-#endif /* defined(__GNUC__) && 0 == __FINITE_MATH_ONLY__ */
-
-/******************************************************************************
- *                                                                            *
- *                              Math Functions                                *
- *                                                                            *
- ******************************************************************************/
-    
-extern float acosf(float);
-extern double acos(double);
-extern long double acosl(long double);
-    
-extern float asinf(float);
-extern double asin(double);
-extern long double asinl(long double);
-    
-extern float atanf(float);
-extern double atan(double);
-extern long double atanl(long double);
-    
-extern float atan2f(float, float);
-extern double atan2(double, double);
-extern long double atan2l(long double, long double);
-    
-extern float cosf(float);
-extern double cos(double);
-extern long double cosl(long double);
-    
-extern float sinf(float);
-extern double sin(double);
-extern long double sinl(long double);
-    
-extern float tanf(float);
-extern double tan(double);
-extern long double tanl(long double);
-    
-extern float acoshf(float);
-extern double acosh(double);
-extern long double acoshl(long double);
-    
-extern float asinhf(float);
-extern double asinh(double);
-extern long double asinhl(long double);
-    
-extern float atanhf(float);
-extern double atanh(double);
-extern long double atanhl(long double);
-    
-extern float coshf(float);
-extern double cosh(double);
-extern long double coshl(long double);
-    
-extern float sinhf(float);
-extern double sinh(double);
-extern long double sinhl(long double);
-    
-extern float tanhf(float);
-extern double tanh(double);
-extern long double tanhl(long double);
-    
-extern float expf(float);
-extern double exp(double);
-extern long double expl(long double);
-
-extern float exp2f(float);
-extern double exp2(double); 
-extern long double exp2l(long double); 
-
-extern float expm1f(float);
-extern double expm1(double); 
-extern long double expm1l(long double); 
-
-extern float logf(float);
-extern double log(double);
-extern long double logl(long double);
-
-extern float log10f(float);
-extern double log10(double);
-extern long double log10l(long double);
-
-extern float log2f(float);
-extern double log2(double);
-extern long double log2l(long double);
-
-extern float log1pf(float);
-extern double log1p(double);
-extern long double log1pl(long double);
-
-extern float logbf(float);
-extern double logb(double);
-extern long double logbl(long double);
-
-extern float modff(float, float *);
-extern double modf(double, double *);
-extern long double modfl(long double, long double *);
-
-extern float ldexpf(float, int);
-extern double ldexp(double, int);
-extern long double ldexpl(long double, int);
-
-extern float frexpf(float, int *);
-extern double frexp(double, int *);
-extern long double frexpl(long double, int *);
-
-extern int ilogbf(float);
-extern int ilogb(double);
-extern int ilogbl(long double);
-
-extern float scalbnf(float, int);
-extern double scalbn(double, int);
-extern long double scalbnl(long double, int);
-
-extern float scalblnf(float, long int);
-extern double scalbln(double, long int);
-extern long double scalblnl(long double, long int);
-
-extern float fabsf(float);
-extern double fabs(double);
-extern long double fabsl(long double);
-
-extern float cbrtf(float);
-extern double cbrt(double);
-extern long double cbrtl(long double);
-
-extern float hypotf(float, float);
-extern double hypot(double, double);
-extern long double hypotl(long double, long double);
-
-extern float powf(float, float);
-extern double pow(double, double);
-extern long double powl(long double, long double);
-
-extern float sqrtf(float);
-extern double sqrt(double);
-extern long double sqrtl(long double);
-
-extern float erff(float);
-extern double erf(double);
-extern long double erfl(long double);
-
-extern float erfcf(float);
-extern double erfc(double);
-extern long double erfcl(long double);
-
-/*	lgammaf, lgamma, and lgammal are not thread-safe. The thread-safe
-    variants lgammaf_r, lgamma_r, and lgammal_r are made available if
-    you define the _REENTRANT symbol before including <math.h>                */
-extern float lgammaf(float);
-extern double lgamma(double);
-extern long double lgammal(long double);
-
-extern float tgammaf(float);
-extern double tgamma(double);
-extern long double tgammal(long double);
-
-extern float ceilf(float);
-extern double ceil(double);
-extern long double ceill(long double);
-
-extern float floorf(float);
-extern double floor(double);
-extern long double floorl(long double);
-
-extern float nearbyintf(float);
-extern double nearbyint(double);
-extern long double nearbyintl(long double);
-
-extern float rintf(float);
-extern double rint(double);
-extern long double rintl(long double);
-
-extern long int lrintf(float);
-extern long int lrint(double);
-extern long int lrintl(long double);
-
-extern float roundf(float);
-extern double round(double);
-extern long double roundl(long double);
-
-extern long int lroundf(float);
-extern long int lround(double);
-extern long int lroundl(long double);
-    
-/*  long long is not part of C90. Make sure you are passing -std=c99 or
-    -std=gnu99 or higher if you need these functions returning long longs     */
-#if !(__DARWIN_NO_LONG_LONG)
-extern long long int llrintf(float);
-extern long long int llrint(double);
-extern long long int llrintl(long double);
-
-extern long long int llroundf(float);
-extern long long int llround(double);
-extern long long int llroundl(long double);
-#endif /* !(__DARWIN_NO_LONG_LONG) */
-
-extern float truncf(float);
-extern double trunc(double);
-extern long double truncl(long double);
-
-extern float fmodf(float, float);
-extern double fmod(double, double);
-extern long double fmodl(long double, long double);
-
-extern float remainderf(float, float);
-extern double remainder(double, double);
-extern long double remainderl(long double, long double);
-
-extern float remquof(float, float, int *);
-extern double remquo(double, double, int *);
-extern long double remquol(long double, long double, int *);
-
-extern float copysignf(float, float);
-extern double copysign(double, double);
-extern long double copysignl(long double, long double);
-
-extern float nanf(const char *);
-extern double nan(const char *);
-extern long double nanl(const char *);
-
-extern float nextafterf(float, float);
-extern double nextafter(double, double);
-extern long double nextafterl(long double, long double);
-
-extern double nexttoward(double, long double);
-extern float nexttowardf(float, long double);
-extern long double nexttowardl(long double, long double);
-
-extern float fdimf(float, float);
-extern double fdim(double, double);
-extern long double fdiml(long double, long double);
-
-extern float fmaxf(float, float);
-extern double fmax(double, double);
-extern long double fmaxl(long double, long double);
-
-extern float fminf(float, float);
-extern double fmin(double, double);
-extern long double fminl(long double, long double);
-
-extern float fmaf(float, float, float);
-extern double fma(double, double, double);
-extern long double fmal(long double, long double, long double);
-
-#define isgreater(x, y) __builtin_isgreater((x),(y))
-#define isgreaterequal(x, y) __builtin_isgreaterequal((x),(y))
-#define isless(x, y) __builtin_isless((x),(y))
-#define islessequal(x, y) __builtin_islessequal((x),(y))
-#define islessgreater(x, y) __builtin_islessgreater((x),(y))
-#define isunordered(x, y) __builtin_isunordered((x),(y))
-
-/* Deprecated functions; use the INFINITY and NAN macros instead.             */
-extern float __inff(void)
-__API_DEPRECATED("use `(float)INFINITY` instead", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-extern double __inf(void)
-__API_DEPRECATED("use `INFINITY` instead", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-extern long double __infl(void)
-__API_DEPRECATED("use `(long double)INFINITY` instead", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-extern float __nan(void)
-__API_DEPRECATED("use `NAN` instead", macos(10.0, 10.14)) __API_UNAVAILABLE(ios, watchos, tvos);
-
-/******************************************************************************
- *  Reentrant variants of lgamma[fl]                                          *
- ******************************************************************************/
-
-#ifdef _REENTRANT
-/*  Reentrant variants of the lgamma[fl] functions.                           */
-extern float lgammaf_r(float, int *) __API_AVAILABLE(macos(10.6), ios(3.1));
-extern double lgamma_r(double, int *) __API_AVAILABLE(macos(10.6), ios(3.1));
-extern long double lgammal_r(long double, int *) __API_AVAILABLE(macos(10.6), ios(3.1));
-#endif /* _REENTRANT */
-
-/******************************************************************************
- *  Apple extensions to the C standard                                        *
- ******************************************************************************/
-
-/*  Because these functions are not specified by any relevant standard, they
-    are prefixed with __, which places them in the implementor's namespace, so
-    they should not conflict with any developer or third-party code.  If they
-    are added to a relevant standard in the future, un-prefixed names may be
-    added to the library and they may be moved out of this section of the
-    header.                                                                   
- 
-    Because these functions are non-standard, they may not be available on non-
-    Apple platforms.                                                          */
-
-/*  __exp10(x) returns 10**x.  Edge cases match those of exp( ) and exp2( ).  */
-extern float __exp10f(float) __API_AVAILABLE(macos(10.9), ios(7.0));
-extern double __exp10(double) __API_AVAILABLE(macos(10.9), ios(7.0));
-
-/*  __sincos(x,sinp,cosp) computes the sine and cosine of x with a single
-    function call, storing the sine in the memory pointed to by sinp, and
-    the cosine in the memory pointed to by cosp. Edge cases match those of
-    separate calls to sin( ) and cos( ).                                      */
-__header_always_inline void __sincosf(float __x, float *__sinp, float *__cosp);
-__header_always_inline void __sincos(double __x, double *__sinp, double *__cosp);
-
-/*  __sinpi(x) returns the sine of pi times x; __cospi(x) and __tanpi(x) return
-    the cosine and tangent, respectively.  These functions can produce a more
-    accurate answer than expressions of the form sin(M_PI * x) because they
-    avoid any loss of precision that results from rounding the result of the
-    multiplication M_PI * x.  They may also be significantly more efficient in
-    some cases because the argument reduction for these functions is easier
-    to compute.  Consult the man pages for edge case details.                 */
-extern float __cospif(float) __API_AVAILABLE(macos(10.9), ios(7.0));
-extern double __cospi(double) __API_AVAILABLE(macos(10.9), ios(7.0));
-extern float __sinpif(float) __API_AVAILABLE(macos(10.9), ios(7.0));
-extern double __sinpi(double) __API_AVAILABLE(macos(10.9), ios(7.0));
-extern float __tanpif(float) __API_AVAILABLE(macos(10.9), ios(7.0));
-extern double __tanpi(double) __API_AVAILABLE(macos(10.9), ios(7.0));
-
-#if (defined __MAC_OS_X_VERSION_MIN_REQUIRED && __MAC_OS_X_VERSION_MIN_REQUIRED < 1090) || \
-    (defined __IPHONE_OS_VERSION_MIN_REQUIRED && __IPHONE_OS_VERSION_MIN_REQUIRED < 70000)
-/*  __sincos and __sincosf were introduced in OSX 10.9 and iOS 7.0.  When
-    targeting an older system, we simply split them up into discrete calls
-    to sin( ) and cos( ).                                                     */
-__header_always_inline void __sincosf(float __x, float *__sinp, float *__cosp) {
-  *__sinp = sinf(__x);
-  *__cosp = cosf(__x);
-}
-
-__header_always_inline void __sincos(double __x, double *__sinp, double *__cosp) {
-  *__sinp = sin(__x);
-  *__cosp = cos(__x);
-}
-#else
-/*  __sincospi(x,sinp,cosp) computes the sine and cosine of pi times x with a
-    single function call, storing the sine in the memory pointed to by sinp,
-    and the cosine in the memory pointed to by cosp.  Edge cases match those
-    of separate calls to __sinpi( ) and __cospi( ), and are documented in the
-    man pages.
- 
-    These functions were introduced in OSX 10.9 and iOS 7.0.  Because they are
-    implemented as header inlines, weak-linking does not function as normal,
-    and they are simply hidden when targeting earlier OS versions.            */
-__header_always_inline void __sincospif(float __x, float *__sinp, float *__cosp);
-__header_always_inline void __sincospi(double __x, double *__sinp, double *__cosp);
-
-/*  Implementation details of __sincos and __sincospi allowing them to return
-    two results while allowing the compiler to optimize away unnecessary load-
-    store traffic.  Although these interfaces are exposed in the math.h header
-    to allow compilers to generate better code, users should call __sincos[f]
-    and __sincospi[f] instead and allow the compiler to emit these calls.     */
-struct __float2 { float __sinval; float __cosval; };
-struct __double2 { double __sinval; double __cosval; };
-
-extern struct __float2 __sincosf_stret(float);
-extern struct __double2 __sincos_stret(double);
-extern struct __float2 __sincospif_stret(float);
-extern struct __double2 __sincospi_stret(double);
-
-__header_always_inline void __sincosf(float __x, float *__sinp, float *__cosp) {
-    const struct __float2 __stret = __sincosf_stret(__x);
-    *__sinp = __stret.__sinval; *__cosp = __stret.__cosval;
-}
-
-__header_always_inline void __sincos(double __x, double *__sinp, double *__cosp) {
-    const struct __double2 __stret = __sincos_stret(__x);
-    *__sinp = __stret.__sinval; *__cosp = __stret.__cosval;
-}
-
-__header_always_inline void __sincospif(float __x, float *__sinp, float *__cosp) {
-    const struct __float2 __stret = __sincospif_stret(__x);
-    *__sinp = __stret.__sinval; *__cosp = __stret.__cosval;
-}
-
-__header_always_inline void __sincospi(double __x, double *__sinp, double *__cosp) {
-    const struct __double2 __stret = __sincospi_stret(__x);
-    *__sinp = __stret.__sinval; *__cosp = __stret.__cosval;
-}
-#endif
-
-/******************************************************************************
- *  POSIX/UNIX extensions to the C standard                                   *
- ******************************************************************************/
-
-#if __DARWIN_C_LEVEL >= 199506L
-extern double j0(double) __API_AVAILABLE(macos(10.0), ios(3.2));
-extern double j1(double) __API_AVAILABLE(macos(10.0), ios(3.2));
-extern double jn(int, double) __API_AVAILABLE(macos(10.0), ios(3.2));
-extern double y0(double) __API_AVAILABLE(macos(10.0), ios(3.2));
-extern double y1(double) __API_AVAILABLE(macos(10.0), ios(3.2));
-extern double yn(int, double) __API_AVAILABLE(macos(10.0), ios(3.2));
-extern double scalb(double, double); 
-extern int signgam;
-
-/*  Even though these might be more useful as long doubles, POSIX requires
-    that they be double-precision literals.                                   */
-#define M_E         2.71828182845904523536028747135266250   /* e              */
-#define M_LOG2E     1.44269504088896340735992468100189214   /* log2(e)        */
-#define M_LOG10E    0.434294481903251827651128918916605082  /* log10(e)       */
-#define M_LN2       0.693147180559945309417232121458176568  /* loge(2)        */
-#define M_LN10      2.30258509299404568401799145468436421   /* loge(10)       */
-#define M_PI        3.14159265358979323846264338327950288   /* pi             */
-#define M_PI_2      1.57079632679489661923132169163975144   /* pi/2           */
-#define M_PI_4      0.785398163397448309615660845819875721  /* pi/4           */
-#define M_1_PI      0.318309886183790671537767526745028724  /* 1/pi           */
-#define M_2_PI      0.636619772367581343075535053490057448  /* 2/pi           */
-#define M_2_SQRTPI  1.12837916709551257389615890312154517   /* 2/sqrt(pi)     */
-#define M_SQRT2     1.41421356237309504880168872420969808   /* sqrt(2)        */
-#define M_SQRT1_2   0.707106781186547524400844362104849039  /* 1/sqrt(2)      */
-
-#define MAXFLOAT    0x1.fffffep+127f
-#endif /* __DARWIN_C_LEVEL >= 199506L */
-
-/*  Long-double versions of M_E, etc for convenience on Intel where long-
-    double is not the same as double.  Define __MATH_LONG_DOUBLE_CONSTANTS
-    to make these constants available.                                        */
-#if defined __MATH_LONG_DOUBLE_CONSTANTS
-#define M_El        0xa.df85458a2bb4a9bp-2L
-#define M_LOG2El    0xb.8aa3b295c17f0bcp-3L
-#define M_LOG10El   0xd.e5bd8a937287195p-5L
-#define M_LN2l      0xb.17217f7d1cf79acp-4L
-#define M_LN10l     0x9.35d8dddaaa8ac17p-2L
-#define M_PIl       0xc.90fdaa22168c235p-2L
-#define M_PI_2l     0xc.90fdaa22168c235p-3L
-#define M_PI_4l     0xc.90fdaa22168c235p-4L
-#define M_1_PIl     0xa.2f9836e4e44152ap-5L
-#define M_2_PIl     0xa.2f9836e4e44152ap-4L
-#define M_2_SQRTPIl 0x9.06eba8214db688dp-3L
-#define M_SQRT2l    0xb.504f333f9de6484p-3L
-#define M_SQRT1_2l  0xb.504f333f9de6484p-4L
-#endif /* defined __MATH_LONG_DOUBLE_CONSTANTS */
-
-/******************************************************************************
- *  Legacy BSD extensions to the C standard                                   *
- ******************************************************************************/
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#define FP_SNAN		FP_NAN
-#define FP_QNAN		FP_NAN
-#define	HUGE		MAXFLOAT
-#define X_TLOSS		1.41484755040568800000e+16 
-#define	DOMAIN		1
-#define	SING		2
-#define	OVERFLOW	3
-#define	UNDERFLOW	4
-#define	TLOSS		5
-#define	PLOSS		6
-
-/* Legacy BSD API; use the C99 `lrint( )` function instead.                   */
-extern long int rinttol(double)
-__API_DEPRECATED_WITH_REPLACEMENT("lrint", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-/* Legacy BSD API; use the C99 `lround( )` function instead.                  */
-extern long int roundtol(double)
-__API_DEPRECATED_WITH_REPLACEMENT("lround", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-/* Legacy BSD API; use the C99 `remainder( )` function instead.               */
-extern double drem(double, double)
-__API_DEPRECATED_WITH_REPLACEMENT("remainder", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-/* Legacy BSD API; use the C99 `isfinite( )` macro instead.                   */
-extern int finite(double)
-__API_DEPRECATED("Use `isfinite((double)x)` instead.", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-/* Legacy BSD API; use the C99 `tgamma( )` function instead.                  */
-extern double gamma(double)
-__API_DEPRECATED_WITH_REPLACEMENT("tgamma", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-/* Legacy BSD API; use `2*frexp( )` or `scalbn(x, -ilogb(x))` instead.        */
-extern double significand(double)
-__API_DEPRECATED("Use `2*frexp( )` or `scalbn(x, -ilogb(x))` instead.", macos(10.0, 10.9)) __API_UNAVAILABLE(ios, watchos, tvos);
-
-#if !defined __cplusplus
-struct exception {
-    int type;
-    char *name;
-    double arg1;
-    double arg2;
-    double retval;
-};
-
-#endif /* !defined __cplusplus */
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-__END_DECLS
-#endif /* __MATH_H__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/net/net_kev.h b/lib/libc/include/x86_64-macos.10-none/net/net_kev.h
deleted file mode 100644
index 0919e59ff2..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/net/net_kev.h
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- * Copyright (c) 2016-2018 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _NET_NETKEV_H_
-#define _NET_NETKEV_H_
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-
-/* Kernel event subclass identifiers for KEV_NETWORK_CLASS */
-#define KEV_INET_SUBCLASS       1       /* inet subclass */
-/* KEV_INET_SUBCLASS event codes */
-#define KEV_INET_NEW_ADDR               1 /* Userland configured IP address */
-#define KEV_INET_CHANGED_ADDR           2 /* Address changed event */
-#define KEV_INET_ADDR_DELETED           3 /* IPv6 address was deleted */
-#define KEV_INET_SIFDSTADDR             4 /* Dest. address was set */
-#define KEV_INET_SIFBRDADDR             5 /* Broadcast address was set */
-#define KEV_INET_SIFNETMASK             6 /* Netmask was set */
-#define KEV_INET_ARPCOLLISION           7 /* ARP collision detected */
-#ifdef __APPLE_API_PRIVATE
-#define KEV_INET_PORTINUSE              8 /* use ken_in_portinuse */
-#endif
-#define KEV_INET_ARPRTRFAILURE          9 /* ARP resolution failed for router */
-#define KEV_INET_ARPRTRALIVE            10 /* ARP resolution succeeded for router */
-
-#define KEV_DL_SUBCLASS 2               /* Data Link subclass */
-/*
- * Define Data-Link event subclass, and associated
- * events.
- */
-#define KEV_DL_SIFFLAGS                         1
-#define KEV_DL_SIFMETRICS                       2
-#define KEV_DL_SIFMTU                           3
-#define KEV_DL_SIFPHYS                          4
-#define KEV_DL_SIFMEDIA                         5
-#define KEV_DL_SIFGENERIC                       6
-#define KEV_DL_ADDMULTI                         7
-#define KEV_DL_DELMULTI                         8
-#define KEV_DL_IF_ATTACHED                      9
-#define KEV_DL_IF_DETACHING                     10
-#define KEV_DL_IF_DETACHED                      11
-#define KEV_DL_LINK_OFF                         12
-#define KEV_DL_LINK_ON                          13
-#define KEV_DL_PROTO_ATTACHED                   14
-#define KEV_DL_PROTO_DETACHED                   15
-#define KEV_DL_LINK_ADDRESS_CHANGED             16
-#define KEV_DL_WAKEFLAGS_CHANGED                17
-#define KEV_DL_IF_IDLE_ROUTE_REFCNT             18
-#define KEV_DL_IFCAP_CHANGED                    19
-#define KEV_DL_LINK_QUALITY_METRIC_CHANGED      20
-#define KEV_DL_NODE_PRESENCE                    21
-#define KEV_DL_NODE_ABSENCE                     22
-#define KEV_DL_MASTER_ELECTED                   23
-#define KEV_DL_ISSUES                           24
-#define KEV_DL_IFDELEGATE_CHANGED               25
-#define KEV_DL_AWDL_RESTRICTED                  26
-#define KEV_DL_AWDL_UNRESTRICTED                27
-#define KEV_DL_RRC_STATE_CHANGED                28
-#define KEV_DL_QOS_MODE_CHANGED                 29
-#define KEV_DL_LOW_POWER_MODE_CHANGED           30
-
-
-#define KEV_INET6_SUBCLASS      6       /* inet6 subclass */
-/* KEV_INET6_SUBCLASS event codes */
-#define KEV_INET6_NEW_USER_ADDR         1 /* Userland configured IPv6 address */
-#define KEV_INET6_CHANGED_ADDR          2 /* Address changed event (future) */
-#define KEV_INET6_ADDR_DELETED          3 /* IPv6 address was deleted */
-#define KEV_INET6_NEW_LL_ADDR           4 /* Autoconf LL address appeared */
-#define KEV_INET6_NEW_RTADV_ADDR        5 /* Autoconf address has appeared */
-#define KEV_INET6_DEFROUTER             6 /* Default router detected */
-#define KEV_INET6_REQUEST_NAT64_PREFIX  7 /* Asking for the NAT64-prefix */
-
-#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-#endif /* _NET_NETKEV_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/pthread_impl.h b/lib/libc/include/x86_64-macos.10-none/pthread_impl.h
deleted file mode 100644
index aae74c2c03..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/pthread_impl.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _PTHREAD_IMPL_H_
-#define _PTHREAD_IMPL_H_
-/*
- * Internal implementation details
- */
-
-/* This whole header file will disappear, so don't depend on it... */
-
-#if __has_feature(assume_nonnull)
-_Pragma("clang assume_nonnull begin")
-#endif
-
-#ifndef __POSIX_LIB__
-
-/*
- * [Internal] data structure signatures
- */
-#define _PTHREAD_MUTEX_SIG_init		0x32AAABA7
-
-#define _PTHREAD_ERRORCHECK_MUTEX_SIG_init      0x32AAABA1
-#define _PTHREAD_RECURSIVE_MUTEX_SIG_init       0x32AAABA2
-#define _PTHREAD_FIRSTFIT_MUTEX_SIG_init       0x32AAABA3
-
-#define _PTHREAD_COND_SIG_init		0x3CB0B1BB
-#define _PTHREAD_ONCE_SIG_init		0x30B1BCBA
-#define _PTHREAD_RWLOCK_SIG_init    0x2DA8B3B4
-
-/*
- * POSIX scheduling policies
- */
-#define SCHED_OTHER                1
-#define SCHED_FIFO                 4
-#define SCHED_RR                   2
-
-#define __SCHED_PARAM_SIZE__       4
-
-#endif /* __POSIX_LIB__ */
-
-#if __has_feature(assume_nonnull)
-_Pragma("clang assume_nonnull end")
-#endif
-
-#endif /* _PTHREAD_IMPL_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sched.h b/lib/libc/include/x86_64-macos.10-none/sched.h
deleted file mode 100644
index 3c49e7980d..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sched.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _SCHED_H_
-#define _SCHED_H_
-
-#include <sys/cdefs.h>
-#include <pthread_impl.h>
-
-__BEGIN_DECLS
-/*
- * Scheduling paramters
- */
-#ifndef __POSIX_LIB__
-struct sched_param { int sched_priority;  char __opaque[__SCHED_PARAM_SIZE__]; };
-#endif
-
-extern int sched_yield(void);
-extern int sched_get_priority_min(int);
-extern int sched_get_priority_max(int);
-__END_DECLS
-
-#endif /* _SCHED_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/signal.h b/lib/libc/include/x86_64-macos.10-none/signal.h
deleted file mode 100644
index dbc5b35f2b..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/signal.h
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-/*-
- * Copyright (c) 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)signal.h	8.3 (Berkeley) 3/30/94
- */
-
-#ifndef _USER_SIGNAL_H
-#define _USER_SIGNAL_H
-
-#include <sys/cdefs.h>
-#include <_types.h>
-#include <sys/signal.h>
-
-#include <sys/_pthread/_pthread_types.h>
-#include <sys/_pthread/_pthread_t.h>
-
-#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
-extern __const char *__const sys_signame[NSIG];
-extern __const char *__const sys_siglist[NSIG];
-#endif
-
-__BEGIN_DECLS
-int	raise(int);
-__END_DECLS
-
-#ifndef	_ANSI_SOURCE
-__BEGIN_DECLS
-void	(* _Nullable bsd_signal(int, void (* _Nullable)(int)))(int);
-int	kill(pid_t, int) __DARWIN_ALIAS(kill);
-int	killpg(pid_t, int) __DARWIN_ALIAS(killpg);
-int	pthread_kill(pthread_t, int);
-int	pthread_sigmask(int, const sigset_t *, sigset_t *) __DARWIN_ALIAS(pthread_sigmask);
-int	sigaction(int, const struct sigaction * __restrict,
-	    struct sigaction * __restrict);
-int	sigaddset(sigset_t *, int);
-int	sigaltstack(const stack_t * __restrict, stack_t * __restrict)  __DARWIN_ALIAS(sigaltstack) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-int	sigdelset(sigset_t *, int);
-int	sigemptyset(sigset_t *);
-int	sigfillset(sigset_t *);
-int	sighold(int);
-int	sigignore(int);
-int	siginterrupt(int, int);
-int	sigismember(const sigset_t *, int);
-int	sigpause(int) __DARWIN_ALIAS_C(sigpause);
-int	sigpending(sigset_t *);
-int	sigprocmask(int, const sigset_t * __restrict, sigset_t * __restrict);
-int	sigrelse(int);
-void    (* _Nullable sigset(int, void (* _Nullable)(int)))(int);
-int	sigsuspend(const sigset_t *) __DARWIN_ALIAS_C(sigsuspend);
-int	sigwait(const sigset_t * __restrict, int * __restrict) __DARWIN_ALIAS_C(sigwait);
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-void	psignal(unsigned int, const char *);
-int	sigblock(int);
-int	sigsetmask(int);
-int	sigvec(int, struct sigvec *, struct sigvec *);
-#endif	/* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-__END_DECLS
-
-/* List definitions after function declarations, or Reiser cpp gets upset. */
-#if defined(__i386__) || defined(__x86_64__)
-/* The left shift operator on intel is modulo 32 */
-__header_always_inline int
-__sigbits(int __signo)
-{
-    return __signo > __DARWIN_NSIG ? 0 : (1 << (__signo - 1));
-}
-#else /* !__i386__ && !__x86_64__ */
-#define __sigbits(signo)	(1 << ((signo) - 1))
-#endif /* __i386__ || __x86_64__ */
-
-#define	sigaddset(set, signo)	(*(set) |= __sigbits(signo), 0)
-#define	sigdelset(set, signo)	(*(set) &= ~__sigbits(signo), 0)
-#define	sigismember(set, signo)	((*(set) & __sigbits(signo)) != 0)
-#define	sigemptyset(set)	(*(set) = 0, 0)
-#define	sigfillset(set)		(*(set) = ~(sigset_t)0, 0)
-#endif	/* !_ANSI_SOURCE */
-
-#endif	/* !_USER_SIGNAL_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/simd/common.h b/lib/libc/include/x86_64-macos.10-none/simd/common.h
deleted file mode 100644
index 4c2f4d0760..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/simd/common.h
+++ /dev/null
@@ -1,4458 +0,0 @@
-/*! @header
- *  The interfaces declared in this header provide "common" elementwise
- *  operations that are neither math nor logic functions.  These are available
- *  only for floating-point vectors and scalars, except for min, max, abs,
- *  clamp, and the reduce operations, which also support integer vectors.
- *
- *      simd_abs(x)             Absolute value of x.  Also available as fabs
- *                              for floating-point vectors.  If x is the
- *                              smallest signed integer, x is returned.
- *
- *      simd_max(x,y)           Returns the maximum of x and y.  Also available
- *                              as fmax for floating-point vectors.
- *
- *      simd_min(x,y)           Returns the minimum of x and y.  Also available
- *                              as fmin for floating-point vectors.
- *
- *      simd_clamp(x,min,max)   x clamped to the range [min, max].
- *
- *      simd_sign(x)            -1 if x is less than zero, 0 if x is zero or
- *                              NaN, and +1 if x is greater than zero.
- *
- *      simd_mix(x,y,t)         If t is not in the range [0,1], the result is
- *                              undefined.  Otherwise the result is x+(y-x)*t,
- *                              which linearly interpolates between x and y.
- *
- *      simd_recip(x)           An approximation to 1/x.  If x is very near the
- *                              limits of representable values, or is infinity
- *                              or NaN, the result is undefined.  There are
- *                              two variants of this function:
- *
- *                                  simd_precise_recip(x)
- *
- *                              and
- *
- *                                  simd_fast_recip(x).
- *
- *                              The "precise" variant is accurate to a few ULPs,
- *                              whereas the "fast" variant may have as little
- *                              as 11 bits of accuracy in float and about 22
- *                              bits in double.
- *
- *                              The function simd_recip(x) resolves to
- *                              simd_precise_recip(x) ordinarily, but to
- *                              simd_fast_recip(x) when used in a translation
- *                              unit compiled with -ffast-math (when
- *                              -ffast-math is in effect, you may still use the
- *                              precise version of this function by calling it
- *                              explicitly by name).
- *
- *      simd_rsqrt(x)           An approximation to 1/sqrt(x).  If x is
- *                              infinity or NaN, the result is undefined.
- *                              There are two variants of this function:
- *
- *                                  simd_precise_rsqrt(x)
- *
- *                              and
- *
- *                                  simd_fast_rsqrt(x).
- *
- *                              The "precise" variant is accurate to a few ULPs,
- *                              whereas the "fast" variant may have as little
- *                              as 11 bits of accuracy in float and about 22
- *                              bits in double.
- *
- *                              The function simd_rsqrt(x) resolves to
- *                              simd_precise_rsqrt(x) ordinarily, but to
- *                              simd_fast_rsqrt(x) when used in a translation
- *                              unit compiled with -ffast-math (when
- *                              -ffast-math is in effect, you may still use the
- *                              precise version of this function by calling it
- *                              explicitly by name).
- *
- *      simd_fract(x)           The "fractional part" of x, which lies strictly
- *                              in the range [0, 0x1.fffffep-1].
- *
- *      simd_step(edge,x)       0 if x < edge, and 1 otherwise.
- *
- *      simd_smoothstep(edge0,edge1,x) 0 if x <= edge0, 1 if x >= edge1, and
- *                              a Hermite interpolation between 0 and 1 if
- *                              edge0 < x < edge1.
- *
- *      simd_reduce_add(x)      Sum of the elements of x.
- *
- *      simd_reduce_min(x)      Minimum of the elements of x.
- *
- *      simd_reduce_max(x)      Maximum of the elements of x.
- *
- *      simd_equal(x,y)         True if and only if every lane of x is equal
- *                              to the corresponding lane of y.
- *
- *  The following common functions are available in the simd:: namespace:
- *
- *      C++ Function                    Equivalent C Function
- *      --------------------------------------------------------------------
- *      simd::abs(x)                    simd_abs(x)
- *      simd::max(x,y)                  simd_max(x,y)
- *      simd::min(x,y)                  simd_min(x,y)
- *      simd::clamp(x,min,max)          simd_clamp(x,min,max)
- *      simd::sign(x)                   simd_sign(x)
- *      simd::mix(x,y,t)                simd_mix(x,y,t)
- *      simd::recip(x)                  simd_recip(x)
- *      simd::rsqrt(x)                  simd_rsqrt(x)
- *      simd::fract(x)                  simd_fract(x)
- *      simd::step(edge,x)              simd_step(edge,x)
- *      simd::smoothstep(e0,e1,x)       simd_smoothstep(e0,e1,x)
- *      simd::reduce_add(x)             simd_reduce_add(x)
- *      simd::reduce_max(x)             simd_reduce_max(x)
- *      simd::reduce_min(x)             simd_reduce_min(x)
- *      simd::equal(x,y)                simd_equal(x,y)
- *
- *      simd::precise::recip(x)         simd_precise_recip(x)
- *      simd::precise::rsqrt(x)         simd_precise_rsqrt(x)
- *
- *      simd::fast::recip(x)            simd_fast_recip(x)
- *      simd::fast::rsqrt(x)            simd_fast_rsqrt(x)
- *
- *  @copyright 2014-2017 Apple, Inc. All rights reserved.
- *  @unsorted                                                                 */
-
-#ifndef SIMD_COMMON_HEADER
-#define SIMD_COMMON_HEADER
-
-#include <simd/base.h>
-#if SIMD_COMPILER_HAS_REQUIRED_FEATURES
-#include <simd/vector_make.h>
-#include <simd/logic.h>
-#include <simd/math.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_char2 simd_abs(simd_char2 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_char3 simd_abs(simd_char3 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_char4 simd_abs(simd_char4 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_char8 simd_abs(simd_char8 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_char16 simd_abs(simd_char16 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_char32 simd_abs(simd_char32 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_char64 simd_abs(simd_char64 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_short2 simd_abs(simd_short2 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_short3 simd_abs(simd_short3 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_short4 simd_abs(simd_short4 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_short8 simd_abs(simd_short8 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_short16 simd_abs(simd_short16 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_short32 simd_abs(simd_short32 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_int2 simd_abs(simd_int2 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_int3 simd_abs(simd_int3 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_int4 simd_abs(simd_int4 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_int8 simd_abs(simd_int8 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_int16 simd_abs(simd_int16 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_float2 simd_abs(simd_float2 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_float3 simd_abs(simd_float3 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_float4 simd_abs(simd_float4 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_float8 simd_abs(simd_float8 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_float16 simd_abs(simd_float16 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_long2 simd_abs(simd_long2 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_long3 simd_abs(simd_long3 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_long4 simd_abs(simd_long4 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_long8 simd_abs(simd_long8 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_double2 simd_abs(simd_double2 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_double3 simd_abs(simd_double3 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_double4 simd_abs(simd_double4 x);
-/*! @abstract The elementwise absolute value of x.                            */
-static inline SIMD_CFUNC simd_double8 simd_abs(simd_double8 x);
-/*! @abstract The elementwise absolute value of x.
- *  @discussion Deprecated. Use simd_abs(x) instead.                          */
-#define vector_abs simd_abs
-  
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_char2 simd_max(simd_char2 x, simd_char2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_char3 simd_max(simd_char3 x, simd_char3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_char4 simd_max(simd_char4 x, simd_char4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_char8 simd_max(simd_char8 x, simd_char8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_char16 simd_max(simd_char16 x, simd_char16 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_char32 simd_max(simd_char32 x, simd_char32 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_char64 simd_max(simd_char64 x, simd_char64 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar2 simd_max(simd_uchar2 x, simd_uchar2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar3 simd_max(simd_uchar3 x, simd_uchar3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar4 simd_max(simd_uchar4 x, simd_uchar4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar8 simd_max(simd_uchar8 x, simd_uchar8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar16 simd_max(simd_uchar16 x, simd_uchar16 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar32 simd_max(simd_uchar32 x, simd_uchar32 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar64 simd_max(simd_uchar64 x, simd_uchar64 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_short2 simd_max(simd_short2 x, simd_short2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_short3 simd_max(simd_short3 x, simd_short3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_short4 simd_max(simd_short4 x, simd_short4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_short8 simd_max(simd_short8 x, simd_short8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_short16 simd_max(simd_short16 x, simd_short16 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_short32 simd_max(simd_short32 x, simd_short32 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort2 simd_max(simd_ushort2 x, simd_ushort2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort3 simd_max(simd_ushort3 x, simd_ushort3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort4 simd_max(simd_ushort4 x, simd_ushort4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort8 simd_max(simd_ushort8 x, simd_ushort8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort16 simd_max(simd_ushort16 x, simd_ushort16 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort32 simd_max(simd_ushort32 x, simd_ushort32 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_int2 simd_max(simd_int2 x, simd_int2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_int3 simd_max(simd_int3 x, simd_int3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_int4 simd_max(simd_int4 x, simd_int4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_int8 simd_max(simd_int8 x, simd_int8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_int16 simd_max(simd_int16 x, simd_int16 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uint2 simd_max(simd_uint2 x, simd_uint2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uint3 simd_max(simd_uint3 x, simd_uint3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uint4 simd_max(simd_uint4 x, simd_uint4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uint8 simd_max(simd_uint8 x, simd_uint8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_uint16 simd_max(simd_uint16 x, simd_uint16 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC float simd_max(float x, float y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_float2 simd_max(simd_float2 x, simd_float2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_float3 simd_max(simd_float3 x, simd_float3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_float4 simd_max(simd_float4 x, simd_float4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_float8 simd_max(simd_float8 x, simd_float8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_float16 simd_max(simd_float16 x, simd_float16 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_long2 simd_max(simd_long2 x, simd_long2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_long3 simd_max(simd_long3 x, simd_long3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_long4 simd_max(simd_long4 x, simd_long4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_long8 simd_max(simd_long8 x, simd_long8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong2 simd_max(simd_ulong2 x, simd_ulong2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong3 simd_max(simd_ulong3 x, simd_ulong3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong4 simd_max(simd_ulong4 x, simd_ulong4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong8 simd_max(simd_ulong8 x, simd_ulong8 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC double simd_max(double x, double y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_double2 simd_max(simd_double2 x, simd_double2 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_double3 simd_max(simd_double3 x, simd_double3 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_double4 simd_max(simd_double4 x, simd_double4 y);
-/*! @abstract The elementwise maximum of x and y.                             */
-static inline SIMD_CFUNC simd_double8 simd_max(simd_double8 x, simd_double8 y);
-/*! @abstract The elementwise maximum of x and y.
- *  @discussion Deprecated. Use simd_max(x,y) instead.                        */
-#define vector_max simd_max
-
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_char2 simd_min(simd_char2 x, simd_char2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_char3 simd_min(simd_char3 x, simd_char3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_char4 simd_min(simd_char4 x, simd_char4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_char8 simd_min(simd_char8 x, simd_char8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_char16 simd_min(simd_char16 x, simd_char16 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_char32 simd_min(simd_char32 x, simd_char32 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_char64 simd_min(simd_char64 x, simd_char64 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar2 simd_min(simd_uchar2 x, simd_uchar2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar3 simd_min(simd_uchar3 x, simd_uchar3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar4 simd_min(simd_uchar4 x, simd_uchar4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar8 simd_min(simd_uchar8 x, simd_uchar8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar16 simd_min(simd_uchar16 x, simd_uchar16 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar32 simd_min(simd_uchar32 x, simd_uchar32 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uchar64 simd_min(simd_uchar64 x, simd_uchar64 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_short2 simd_min(simd_short2 x, simd_short2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_short3 simd_min(simd_short3 x, simd_short3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_short4 simd_min(simd_short4 x, simd_short4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_short8 simd_min(simd_short8 x, simd_short8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_short16 simd_min(simd_short16 x, simd_short16 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_short32 simd_min(simd_short32 x, simd_short32 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort2 simd_min(simd_ushort2 x, simd_ushort2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort3 simd_min(simd_ushort3 x, simd_ushort3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort4 simd_min(simd_ushort4 x, simd_ushort4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort8 simd_min(simd_ushort8 x, simd_ushort8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort16 simd_min(simd_ushort16 x, simd_ushort16 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ushort32 simd_min(simd_ushort32 x, simd_ushort32 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_int2 simd_min(simd_int2 x, simd_int2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_int3 simd_min(simd_int3 x, simd_int3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_int4 simd_min(simd_int4 x, simd_int4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_int8 simd_min(simd_int8 x, simd_int8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_int16 simd_min(simd_int16 x, simd_int16 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uint2 simd_min(simd_uint2 x, simd_uint2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uint3 simd_min(simd_uint3 x, simd_uint3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uint4 simd_min(simd_uint4 x, simd_uint4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uint8 simd_min(simd_uint8 x, simd_uint8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_uint16 simd_min(simd_uint16 x, simd_uint16 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC float simd_min(float x, float y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_float2 simd_min(simd_float2 x, simd_float2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_float3 simd_min(simd_float3 x, simd_float3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_float4 simd_min(simd_float4 x, simd_float4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_float8 simd_min(simd_float8 x, simd_float8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_float16 simd_min(simd_float16 x, simd_float16 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_long2 simd_min(simd_long2 x, simd_long2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_long3 simd_min(simd_long3 x, simd_long3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_long4 simd_min(simd_long4 x, simd_long4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_long8 simd_min(simd_long8 x, simd_long8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong2 simd_min(simd_ulong2 x, simd_ulong2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong3 simd_min(simd_ulong3 x, simd_ulong3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong4 simd_min(simd_ulong4 x, simd_ulong4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_ulong8 simd_min(simd_ulong8 x, simd_ulong8 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC double simd_min(double x, double y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_double2 simd_min(simd_double2 x, simd_double2 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_double3 simd_min(simd_double3 x, simd_double3 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_double4 simd_min(simd_double4 x, simd_double4 y);
-/*! @abstract The elementwise minimum of x and y.                             */
-static inline SIMD_CFUNC simd_double8 simd_min(simd_double8 x, simd_double8 y);
-/*! @abstract The elementwise minimum of x and y.
- *  @discussion Deprecated. Use simd_min(x,y) instead.                        */
-#define vector_min simd_min
-
-  
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_char2 simd_clamp(simd_char2 x, simd_char2 min, simd_char2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_char3 simd_clamp(simd_char3 x, simd_char3 min, simd_char3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_char4 simd_clamp(simd_char4 x, simd_char4 min, simd_char4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_char8 simd_clamp(simd_char8 x, simd_char8 min, simd_char8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_char16 simd_clamp(simd_char16 x, simd_char16 min, simd_char16 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_char32 simd_clamp(simd_char32 x, simd_char32 min, simd_char32 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_char64 simd_clamp(simd_char64 x, simd_char64 min, simd_char64 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uchar2 simd_clamp(simd_uchar2 x, simd_uchar2 min, simd_uchar2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uchar3 simd_clamp(simd_uchar3 x, simd_uchar3 min, simd_uchar3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uchar4 simd_clamp(simd_uchar4 x, simd_uchar4 min, simd_uchar4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uchar8 simd_clamp(simd_uchar8 x, simd_uchar8 min, simd_uchar8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uchar16 simd_clamp(simd_uchar16 x, simd_uchar16 min, simd_uchar16 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uchar32 simd_clamp(simd_uchar32 x, simd_uchar32 min, simd_uchar32 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uchar64 simd_clamp(simd_uchar64 x, simd_uchar64 min, simd_uchar64 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_short2 simd_clamp(simd_short2 x, simd_short2 min, simd_short2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_short3 simd_clamp(simd_short3 x, simd_short3 min, simd_short3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_short4 simd_clamp(simd_short4 x, simd_short4 min, simd_short4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_short8 simd_clamp(simd_short8 x, simd_short8 min, simd_short8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_short16 simd_clamp(simd_short16 x, simd_short16 min, simd_short16 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_short32 simd_clamp(simd_short32 x, simd_short32 min, simd_short32 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ushort2 simd_clamp(simd_ushort2 x, simd_ushort2 min, simd_ushort2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ushort3 simd_clamp(simd_ushort3 x, simd_ushort3 min, simd_ushort3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ushort4 simd_clamp(simd_ushort4 x, simd_ushort4 min, simd_ushort4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ushort8 simd_clamp(simd_ushort8 x, simd_ushort8 min, simd_ushort8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ushort16 simd_clamp(simd_ushort16 x, simd_ushort16 min, simd_ushort16 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ushort32 simd_clamp(simd_ushort32 x, simd_ushort32 min, simd_ushort32 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_int2 simd_clamp(simd_int2 x, simd_int2 min, simd_int2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_int3 simd_clamp(simd_int3 x, simd_int3 min, simd_int3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_int4 simd_clamp(simd_int4 x, simd_int4 min, simd_int4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_int8 simd_clamp(simd_int8 x, simd_int8 min, simd_int8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_int16 simd_clamp(simd_int16 x, simd_int16 min, simd_int16 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uint2 simd_clamp(simd_uint2 x, simd_uint2 min, simd_uint2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uint3 simd_clamp(simd_uint3 x, simd_uint3 min, simd_uint3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uint4 simd_clamp(simd_uint4 x, simd_uint4 min, simd_uint4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uint8 simd_clamp(simd_uint8 x, simd_uint8 min, simd_uint8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_uint16 simd_clamp(simd_uint16 x, simd_uint16 min, simd_uint16 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC float simd_clamp(float x, float min, float max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_float2 simd_clamp(simd_float2 x, simd_float2 min, simd_float2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_float3 simd_clamp(simd_float3 x, simd_float3 min, simd_float3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_float4 simd_clamp(simd_float4 x, simd_float4 min, simd_float4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_float8 simd_clamp(simd_float8 x, simd_float8 min, simd_float8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_float16 simd_clamp(simd_float16 x, simd_float16 min, simd_float16 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_long2 simd_clamp(simd_long2 x, simd_long2 min, simd_long2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_long3 simd_clamp(simd_long3 x, simd_long3 min, simd_long3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_long4 simd_clamp(simd_long4 x, simd_long4 min, simd_long4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_long8 simd_clamp(simd_long8 x, simd_long8 min, simd_long8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ulong2 simd_clamp(simd_ulong2 x, simd_ulong2 min, simd_ulong2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ulong3 simd_clamp(simd_ulong3 x, simd_ulong3 min, simd_ulong3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ulong4 simd_clamp(simd_ulong4 x, simd_ulong4 min, simd_ulong4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_ulong8 simd_clamp(simd_ulong8 x, simd_ulong8 min, simd_ulong8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC double simd_clamp(double x, double min, double max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_double2 simd_clamp(simd_double2 x, simd_double2 min, simd_double2 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_double3 simd_clamp(simd_double3 x, simd_double3 min, simd_double3 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_double4 simd_clamp(simd_double4 x, simd_double4 min, simd_double4 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Note that if you want to clamp all lanes to the same range,
- *  you can use a scalar value for min and max.                               */
-static inline SIMD_CFUNC simd_double8 simd_clamp(simd_double8 x, simd_double8 min, simd_double8 max);
-/*! @abstract x clamped to the range [min, max].
- *  @discussion Deprecated. Use simd_clamp(x,min,max) instead.                */
-#define vector_clamp simd_clamp
-  
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC float simd_sign(float x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_float2 simd_sign(simd_float2 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_float3 simd_sign(simd_float3 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_float4 simd_sign(simd_float4 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_float8 simd_sign(simd_float8 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_float16 simd_sign(simd_float16 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC double simd_sign(double x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_double2 simd_sign(simd_double2 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_double3 simd_sign(simd_double3 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_double4 simd_sign(simd_double4 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.      */
-static inline SIMD_CFUNC simd_double8 simd_sign(simd_double8 x);
-/*! @abstract -1 if x is negative, +1 if x is positive, and 0 otherwise.
- *  @discussion Deprecated. Use simd_sign(x) instead.                         */
-#define vector_sign simd_sign
-
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC float simd_mix(float x, float y, float t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_float2 simd_mix(simd_float2 x, simd_float2 y, simd_float2 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_float3 simd_mix(simd_float3 x, simd_float3 y, simd_float3 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_float4 simd_mix(simd_float4 x, simd_float4 y, simd_float4 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_float8 simd_mix(simd_float8 x, simd_float8 y, simd_float8 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_float16 simd_mix(simd_float16 x, simd_float16 y, simd_float16 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC double simd_mix(double x, double y, double t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_double2 simd_mix(simd_double2 x, simd_double2 y, simd_double2 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_double3 simd_mix(simd_double3 x, simd_double3 y, simd_double3 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_double4 simd_mix(simd_double4 x, simd_double4 y, simd_double4 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1                                                        */
-static inline SIMD_CFUNC simd_double8 simd_mix(simd_double8 x, simd_double8 y, simd_double8 t);
-/*! @abstract Linearly interpolates between x and y, taking the value x when
- *  t=0 and y when t=1
- *  @discussion Deprecated. Use simd_mix(x, y, t) instead.                    */
-#define vector_mix simd_mix
-
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC float simd_precise_recip(float x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_float2 simd_precise_recip(simd_float2 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_float3 simd_precise_recip(simd_float3 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_float4 simd_precise_recip(simd_float4 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_float8 simd_precise_recip(simd_float8 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_float16 simd_precise_recip(simd_float16 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC double simd_precise_recip(double x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_double2 simd_precise_recip(simd_double2 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_double3 simd_precise_recip(simd_double3 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_double4 simd_precise_recip(simd_double4 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  a few units in the last place (ULPs).                                     */
-static inline SIMD_CFUNC simd_double8 simd_precise_recip(simd_double8 x);
-/*! @abstract A good approximation to 1/x.
- *  @discussion Deprecated. Use simd_precise_recip(x) instead.                */
-#define vector_precise_recip simd_precise_recip
-
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC float simd_fast_recip(float x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_float2 simd_fast_recip(simd_float2 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_float3 simd_fast_recip(simd_float3 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_float4 simd_fast_recip(simd_float4 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_float8 simd_fast_recip(simd_float8 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_float16 simd_fast_recip(simd_float16 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC double simd_fast_recip(double x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_double2 simd_fast_recip(simd_double2 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_double3 simd_fast_recip(simd_double3 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_double4 simd_fast_recip(simd_double4 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow; otherwise this function is accurate to
- *  at least 11 bits for float and 22 bits for double.                        */
-static inline SIMD_CFUNC simd_double8 simd_fast_recip(simd_double8 x);
-/*! @abstract A fast approximation to 1/x.
- *  @discussion Deprecated. Use simd_fast_recip(x) instead.                   */
-#define vector_fast_recip simd_fast_recip
-
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC float simd_recip(float x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_float2 simd_recip(simd_float2 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_float3 simd_recip(simd_float3 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_float4 simd_recip(simd_float4 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_float8 simd_recip(simd_float8 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_float16 simd_recip(simd_float16 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC double simd_recip(double x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_double2 simd_recip(simd_double2 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_double3 simd_recip(simd_double3 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_double4 simd_recip(simd_double4 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion If x is very close to the limits of representation, the
- *  result may overflow or underflow. This function maps to
- *  simd_fast_recip(x) if -ffast-math is specified, and to
- *  simd_precise_recip(x) otherwise.                                          */
-static inline SIMD_CFUNC simd_double8 simd_recip(simd_double8 x);
-/*! @abstract An approximation to 1/x.
- *  @discussion Deprecated. Use simd_recip(x) instead.                        */
-#define vector_recip simd_recip
-
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC float simd_precise_rsqrt(float x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_float2 simd_precise_rsqrt(simd_float2 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_float3 simd_precise_rsqrt(simd_float3 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_float4 simd_precise_rsqrt(simd_float4 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_float8 simd_precise_rsqrt(simd_float8 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_float16 simd_precise_rsqrt(simd_float16 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC double simd_precise_rsqrt(double x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_double2 simd_precise_rsqrt(simd_double2 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_double3 simd_precise_rsqrt(simd_double3 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_double4 simd_precise_rsqrt(simd_double4 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion This function is accurate to a few units in the last place
- *  (ULPs).                                                                   */
-static inline SIMD_CFUNC simd_double8 simd_precise_rsqrt(simd_double8 x);
-/*! @abstract A good approximation to 1/sqrt(x).
- *  @discussion Deprecated. Use simd_precise_rsqrt(x) instead.                */
-#define vector_precise_rsqrt simd_precise_rsqrt
-
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC float simd_fast_rsqrt(float x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_float2 simd_fast_rsqrt(simd_float2 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_float3 simd_fast_rsqrt(simd_float3 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_float4 simd_fast_rsqrt(simd_float4 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_float8 simd_fast_rsqrt(simd_float8 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_float16 simd_fast_rsqrt(simd_float16 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC double simd_fast_rsqrt(double x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_double2 simd_fast_rsqrt(simd_double2 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_double3 simd_fast_rsqrt(simd_double3 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_double4 simd_fast_rsqrt(simd_double4 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion This function is accurate to at least 11 bits for float and
- *  22 bits for double.                                                       */
-static inline SIMD_CFUNC simd_double8 simd_fast_rsqrt(simd_double8 x);
-/*! @abstract A fast approximation to 1/sqrt(x).
- *  @discussion Deprecated. Use simd_fast_rsqrt(x) instead.                   */
-#define vector_fast_rsqrt simd_fast_rsqrt
-
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC float simd_rsqrt(float x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_float2 simd_rsqrt(simd_float2 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_float3 simd_rsqrt(simd_float3 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_float4 simd_rsqrt(simd_float4 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_float8 simd_rsqrt(simd_float8 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_float16 simd_rsqrt(simd_float16 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC double simd_rsqrt(double x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_double2 simd_rsqrt(simd_double2 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_double3 simd_rsqrt(simd_double3 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_double4 simd_rsqrt(simd_double4 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion This function maps to simd_fast_recip(x) if -ffast-math is
- *  specified, and to simd_precise_recip(x) otherwise.                        */
-static inline SIMD_CFUNC simd_double8 simd_rsqrt(simd_double8 x);
-/*! @abstract An approximation to 1/sqrt(x).
- *  @discussion Deprecated. Use simd_rsqrt(x) instead.                        */
-#define vector_rsqrt simd_rsqrt
-
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC float simd_fract(float x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_float2 simd_fract(simd_float2 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_float3 simd_fract(simd_float3 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_float4 simd_fract(simd_float4 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_float8 simd_fract(simd_float8 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_float16 simd_fract(simd_float16 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC double simd_fract(double x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_double2 simd_fract(simd_double2 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_double3 simd_fract(simd_double3 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_double4 simd_fract(simd_double4 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion floor(x) + fract(x) is *approximately* equal to x. If x is
- *  positive and finite, then the two values are exactly equal.               */
-static inline SIMD_CFUNC simd_double8 simd_fract(simd_double8 x);
-/*! @abstract The "fractional part" of x, lying in the range [0, 1).
- *  @discussion Deprecated. Use simd_fract(x) instead.                        */
-#define vector_fract simd_fract
-
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC float simd_step(float edge, float x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_float2 simd_step(simd_float2 edge, simd_float2 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_float3 simd_step(simd_float3 edge, simd_float3 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_float4 simd_step(simd_float4 edge, simd_float4 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_float8 simd_step(simd_float8 edge, simd_float8 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_float16 simd_step(simd_float16 edge, simd_float16 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC double simd_step(double edge, double x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_double2 simd_step(simd_double2 edge, simd_double2 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_double3 simd_step(simd_double3 edge, simd_double3 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_double4 simd_step(simd_double4 edge, simd_double4 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Use a scalar value for edge if you want to apply the same
- *  threshold to all lanes.                                                   */
-static inline SIMD_CFUNC simd_double8 simd_step(simd_double8 edge, simd_double8 x);
-/*! @abstract 0 if x < edge, and 1 otherwise.
- *  @discussion Deprecated. Use simd_step(edge, x) instead.                   */
-#define vector_step simd_step
-
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC float simd_smoothstep(float edge0, float edge1, float x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_float2 simd_smoothstep(simd_float2 edge0, simd_float2 edge1, simd_float2 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_float3 simd_smoothstep(simd_float3 edge0, simd_float3 edge1, simd_float3 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_float4 simd_smoothstep(simd_float4 edge0, simd_float4 edge1, simd_float4 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_float8 simd_smoothstep(simd_float8 edge0, simd_float8 edge1, simd_float8 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_float16 simd_smoothstep(simd_float16 edge0, simd_float16 edge1, simd_float16 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC double simd_smoothstep(double edge0, double edge1, double x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_double2 simd_smoothstep(simd_double2 edge0, simd_double2 edge1, simd_double2 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_double3 simd_smoothstep(simd_double3 edge0, simd_double3 edge1, simd_double3 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_double4 simd_smoothstep(simd_double4 edge0, simd_double4 edge1, simd_double4 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion You can use a scalar value for edge0 and edge1 if you want
- *  to clamp all lanes at the same points.                                    */
-static inline SIMD_CFUNC simd_double8 simd_smoothstep(simd_double8 edge0, simd_double8 edge1, simd_double8 x);
-/*! @abstract Interpolates smoothly between 0 at edge0 and 1 at edge1
- *  @discussion Deprecated. Use simd_smoothstep(edge0, edge1, x) instead.     */
-#define vector_smoothstep simd_smoothstep
-
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC char simd_reduce_add(simd_char2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC char simd_reduce_add(simd_char3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC char simd_reduce_add(simd_char4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC char simd_reduce_add(simd_char8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC char simd_reduce_add(simd_char16 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC char simd_reduce_add(simd_char32 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC char simd_reduce_add(simd_char64 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar16 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar32 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar64 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC short simd_reduce_add(simd_short2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC short simd_reduce_add(simd_short3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC short simd_reduce_add(simd_short4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC short simd_reduce_add(simd_short8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC short simd_reduce_add(simd_short16 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC short simd_reduce_add(simd_short32 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort16 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort32 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC int simd_reduce_add(simd_int2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC int simd_reduce_add(simd_int3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC int simd_reduce_add(simd_int4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC int simd_reduce_add(simd_int8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC int simd_reduce_add(simd_int16 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint16 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC float simd_reduce_add(simd_float2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC float simd_reduce_add(simd_float3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC float simd_reduce_add(simd_float4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC float simd_reduce_add(simd_float8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC float simd_reduce_add(simd_float16 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC double simd_reduce_add(simd_double2 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC double simd_reduce_add(simd_double3 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC double simd_reduce_add(simd_double4 x);
-/*! @abstract Sum of elements in x.
- *  @discussion This computation may overflow; especial for 8-bit types you
- *  may need to convert to a wider type before reducing.                      */
-static inline SIMD_CFUNC double simd_reduce_add(simd_double8 x);
-/*! @abstract Sum of elements in x.
- *  @discussion Deprecated. Use simd_add(x) instead.                          */
-#define vector_reduce_add simd_reduce_add
-  
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_min(simd_char2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_min(simd_char3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_min(simd_char4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_min(simd_char8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_min(simd_char16 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_min(simd_char32 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_min(simd_char64 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar16 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar32 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar64 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_min(simd_short2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_min(simd_short3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_min(simd_short4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_min(simd_short8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_min(simd_short16 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_min(simd_short32 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort16 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort32 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_min(simd_int2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_min(simd_int3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_min(simd_int4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_min(simd_int8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_min(simd_int16 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint16 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_min(simd_float2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_min(simd_float3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_min(simd_float4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_min(simd_float8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_min(simd_float16 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong8 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_min(simd_double2 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_min(simd_double3 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_min(simd_double4 x);
-/*! @abstract Minimum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_min(simd_double8 x);
-/*! @abstract Minimum of elements in x.
- *  @discussion Deprecated. Use simd_min(x) instead.                          */
-#define vector_reduce_min simd_reduce_min
-  
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_max(simd_char2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_max(simd_char3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_max(simd_char4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_max(simd_char8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_max(simd_char16 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_max(simd_char32 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC char simd_reduce_max(simd_char64 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar16 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar32 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar64 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_max(simd_short2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_max(simd_short3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_max(simd_short4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_max(simd_short8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_max(simd_short16 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC short simd_reduce_max(simd_short32 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort16 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort32 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_max(simd_int2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_max(simd_int3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_max(simd_int4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_max(simd_int8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC int simd_reduce_max(simd_int16 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint16 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_max(simd_float2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_max(simd_float3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_max(simd_float4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_max(simd_float8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC float simd_reduce_max(simd_float16 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong8 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_max(simd_double2 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_max(simd_double3 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_max(simd_double4 x);
-/*! @abstract Maximum of elements in x.                                       */
-static inline SIMD_CFUNC double simd_reduce_max(simd_double8 x);
-/*! @abstract Maximum of elements in x.
- *  @discussion Deprecated. Use simd_max(x) instead.                          */
-#define vector_reduce_max simd_reduce_max
-  
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_char2 x, simd_char2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_char3 x, simd_char3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_char4 x, simd_char4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_char8 x, simd_char8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_char16 x, simd_char16 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_char32 x, simd_char32 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_char64 x, simd_char64 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uchar2 x, simd_uchar2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uchar3 x, simd_uchar3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uchar4 x, simd_uchar4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uchar8 x, simd_uchar8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uchar16 x, simd_uchar16 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uchar32 x, simd_uchar32 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uchar64 x, simd_uchar64 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_short2 x, simd_short2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_short3 x, simd_short3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_short4 x, simd_short4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_short8 x, simd_short8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_short16 x, simd_short16 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_short32 x, simd_short32 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ushort2 x, simd_ushort2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ushort3 x, simd_ushort3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ushort4 x, simd_ushort4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ushort8 x, simd_ushort8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ushort16 x, simd_ushort16 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ushort32 x, simd_ushort32 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_int2 x, simd_int2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_int3 x, simd_int3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_int4 x, simd_int4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_int8 x, simd_int8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_int16 x, simd_int16 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uint2 x, simd_uint2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uint3 x, simd_uint3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uint4 x, simd_uint4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uint8 x, simd_uint8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_uint16 x, simd_uint16 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_float2 x, simd_float2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_float3 x, simd_float3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_float4 x, simd_float4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_float8 x, simd_float8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_float16 x, simd_float16 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_long2 x, simd_long2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_long3 x, simd_long3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_long4 x, simd_long4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_long8 x, simd_long8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ulong2 x, simd_ulong2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ulong3 x, simd_ulong3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ulong4 x, simd_ulong4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_ulong8 x, simd_ulong8 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_double2 x, simd_double2 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_double3 x, simd_double3 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_double4 x, simd_double4 y) {
-  return simd_all(x == y);
-}
-/*! @abstract True if and only if each lane of x is equal to the
- *  corresponding lane of y.                                                  */
-static inline SIMD_CFUNC simd_bool simd_equal(simd_double8 x, simd_double8 y) {
-  return simd_all(x == y);
-}
-  
-#ifdef __cplusplus
-} /* extern "C" */
-
-namespace simd {
-  /*! @abstract The lanewise absolute value of x.                             */
-  template <typename typeN> static SIMD_CPPFUNC typeN abs(const typeN x) { return ::simd_abs(x); }
-  /*! @abstract The lanewise maximum of x and y.                              */
-  template <typename typeN> static SIMD_CPPFUNC typeN max(const typeN x, const typeN y) { return ::simd_max(x,y); }
-  /*! @abstract The lanewise minimum of x and y.                              */
-  template <typename typeN> static SIMD_CPPFUNC typeN min(const typeN x, const typeN y) { return ::simd_min(x,y); }
-  /*! @abstract x clamped to the interval [min, max].                         */
-  template <typename typeN> static SIMD_CPPFUNC typeN clamp(const typeN x, const typeN min, const typeN max) { return ::simd_clamp(x,min,max); }
-  /*! @abstract -1 if x < 0, +1 if x > 0, and 0 otherwise.                    */
-  template <typename fptypeN> static SIMD_CPPFUNC fptypeN sign(const fptypeN x) { return ::simd_sign(x); }
-  /*! @abstract Linearly interpolates between x and y, taking the value x when t=0 and y when t=1 */
-  template <typename fptypeN> static SIMD_CPPFUNC fptypeN mix(const fptypeN x, const fptypeN y, const fptypeN t) { return ::simd_mix(x,y,t); }
-  /*! @abstract An approximation to 1/x.                                      */
-  template <typename fptypeN> static SIMD_CPPFUNC fptypeN recip(const fptypeN x) { return simd_recip(x); }
-  /*! @abstract An approximation to 1/sqrt(x).                                */
-  template <typename fptypeN> static SIMD_CPPFUNC fptypeN rsqrt(const fptypeN x) { return simd_rsqrt(x); }
-  /*! @abstract The "fracional part" of x, in the range [0,1).                */
-  template <typename fptypeN> static SIMD_CPPFUNC fptypeN fract(const fptypeN x) { return ::simd_fract(x); }
-  /*! @abstract 0 if x < edge, 1 otherwise.                                   */
-  template <typename fptypeN> static SIMD_CPPFUNC fptypeN step(const fptypeN edge, const fptypeN x) { return ::simd_step(edge,x); }
-  /*! @abstract smoothly interpolates from 0 at edge0 to 1 at edge1.          */
-  template <typename fptypeN> static SIMD_CPPFUNC fptypeN smoothstep(const fptypeN edge0, const fptypeN edge1, const fptypeN x) { return ::simd_smoothstep(edge0,edge1,x); }
-  /*! @abstract True if and only if each lane of x is equal to the
-   *  corresponding lane of y.
-   *
-   *  @discussion This isn't operator== because that's already defined by
-   *  the compiler to return a lane mask.                                     */
-  template <typename fptypeN> static SIMD_CPPFUNC simd_bool equal(const fptypeN x, const fptypeN y) { return ::simd_equal(x, y); }
-#if __cpp_decltype_auto
-  /*  If you are targeting an earlier version of the C++ standard that lacks
-   decltype_auto support, you may use the C-style simd_reduce_* functions
-   instead.                                                                   */
-  /*! @abstract The sum of the elements in x. May overflow.                   */
-  template <typename typeN> static SIMD_CPPFUNC auto reduce_add(typeN x) { return ::simd_reduce_add(x); }
-  /*! @abstract The least element in x.                                       */
-  template <typename typeN> static SIMD_CPPFUNC auto reduce_min(typeN x) { return ::simd_reduce_min(x); }
-  /*! @abstract The greatest element in x.                                    */
-  template <typename typeN> static SIMD_CPPFUNC auto reduce_max(typeN x) { return ::simd_reduce_max(x); }
-#endif
-  namespace precise {
-    /*! @abstract An approximation to 1/x.                                      */
-    template <typename fptypeN> static SIMD_CPPFUNC fptypeN recip(const fptypeN x) { return ::simd_precise_recip(x); }
-    /*! @abstract An approximation to 1/sqrt(x).                                */
-    template <typename fptypeN> static SIMD_CPPFUNC fptypeN rsqrt(const fptypeN x) { return ::simd_precise_rsqrt(x); }
-  }
-  namespace fast {
-    /*! @abstract An approximation to 1/x.                                      */
-    template <typename fptypeN> static SIMD_CPPFUNC fptypeN recip(const fptypeN x) { return ::simd_fast_recip(x); }
-    /*! @abstract An approximation to 1/sqrt(x).                                */
-    template <typename fptypeN> static SIMD_CPPFUNC fptypeN rsqrt(const fptypeN x) { return ::simd_fast_rsqrt(x); }
-  }
-}
-
-extern "C" {
-#endif /* __cplusplus */
-
-#pragma mark - Implementation
-
-static inline SIMD_CFUNC simd_char2 simd_abs(simd_char2 x) {
-  return simd_make_char2(simd_abs(simd_make_char8_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_char3 simd_abs(simd_char3 x) {
-  return simd_make_char3(simd_abs(simd_make_char8_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_char4 simd_abs(simd_char4 x) {
-  return simd_make_char4(simd_abs(simd_make_char8_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_char8 simd_abs(simd_char8 x) {
-#if defined __arm__ || defined __arm64__
-  return vabs_s8(x);
-#else
-  return simd_make_char8(simd_abs(simd_make_char16_undef(x)));
-#endif
-}
-
-static inline SIMD_CFUNC simd_char16 simd_abs(simd_char16 x) {
-#if defined __arm__ || defined __arm64__
-  return vabsq_s8(x);
-#elif defined __SSE4_1__
-  return _mm_abs_epi8(x);
-#else
-  simd_char16 mask = x >> 7; return (x ^ mask) - mask;
-#endif
-}
-
-static inline SIMD_CFUNC simd_char32 simd_abs(simd_char32 x) {
-#if defined __AVX2__
-  return _mm256_abs_epi8(x);
-#else
-  return simd_make_char32(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_char64 simd_abs(simd_char64 x) {
-#if defined __AVX512BW__
-  return _mm512_abs_epi8(x);
-#else
-  return simd_make_char64(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_short2 simd_abs(simd_short2 x) {
-  return simd_make_short2(simd_abs(simd_make_short4_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_short3 simd_abs(simd_short3 x) {
-  return simd_make_short3(simd_abs(simd_make_short4_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_short4 simd_abs(simd_short4 x) {
-#if defined __arm__ || defined __arm64__
-  return vabs_s16(x);
-#else
-  return simd_make_short4(simd_abs(simd_make_short8_undef(x)));
-#endif
-}
-
-static inline SIMD_CFUNC simd_short8 simd_abs(simd_short8 x) {
-#if defined __arm__ || defined __arm64__
-  return vabsq_s16(x);
-#elif defined __SSE4_1__
-  return _mm_abs_epi16(x);
-#else
-  simd_short8 mask = x >> 15; return (x ^ mask) - mask;
-#endif
-}
-
-static inline SIMD_CFUNC simd_short16 simd_abs(simd_short16 x) {
-#if defined __AVX2__
-  return _mm256_abs_epi16(x);
-#else
-  return simd_make_short16(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_short32 simd_abs(simd_short32 x) {
-#if defined __AVX512BW__
-  return _mm512_abs_epi16(x);
-#else
-  return simd_make_short32(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_int2 simd_abs(simd_int2 x) {
-#if defined __arm__ || defined __arm64__
-  return vabs_s32(x);
-#else
-  return simd_make_int2(simd_abs(simd_make_int4_undef(x)));
-#endif
-}
-
-static inline SIMD_CFUNC simd_int3 simd_abs(simd_int3 x) {
-  return simd_make_int3(simd_abs(simd_make_int4_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_int4 simd_abs(simd_int4 x) {
-#if defined __arm__ || defined __arm64__
-  return vabsq_s32(x);
-#elif defined __SSE4_1__
-  return _mm_abs_epi32(x);
-#else
-  simd_int4 mask = x >> 31; return (x ^ mask) - mask;
-#endif
-}
-
-static inline SIMD_CFUNC simd_int8 simd_abs(simd_int8 x) {
-#if defined __AVX2__
-  return _mm256_abs_epi32(x);
-#else
-  return simd_make_int8(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_int16 simd_abs(simd_int16 x) {
-#if defined __AVX512F__
-  return _mm512_abs_epi32(x);
-#else
-  return simd_make_int16(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_float2 simd_abs(simd_float2 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_abs(simd_float3 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_abs(simd_float4 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_abs(simd_float8 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_abs(simd_float16 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_long2 simd_abs(simd_long2 x) {
-#if defined __arm64__
-  return vabsq_s64(x);
-#elif defined __SSE4_1__
-  return _mm_abs_epi64(x);
-#else
-  simd_long2 mask = x >> 63; return (x ^ mask) - mask;
-#endif
-}
-
-static inline SIMD_CFUNC simd_long3 simd_abs(simd_long3 x) {
-  return simd_make_long3(simd_abs(simd_make_long4_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_long4 simd_abs(simd_long4 x) {
-#if defined __AVX2__
-  return _mm256_abs_epi64(x);
-#else
-  return simd_make_long4(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_long8 simd_abs(simd_long8 x) {
-#if defined __AVX512F__
-  return _mm512_abs_epi64(x);
-#else
-  return simd_make_long8(simd_abs(x.lo), simd_abs(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_double2 simd_abs(simd_double2 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_abs(simd_double3 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_abs(simd_double4 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_abs(simd_double8 x) {
-  return __tg_fabs(x);
-}
-
-static inline SIMD_CFUNC simd_char2 simd_min(simd_char2 x, simd_char2 y) {
-  return simd_make_char2(simd_min(simd_make_char8_undef(x), simd_make_char8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_char3 simd_min(simd_char3 x, simd_char3 y) {
-  return simd_make_char3(simd_min(simd_make_char8_undef(x), simd_make_char8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_char4 simd_min(simd_char4 x, simd_char4 y) {
-  return simd_make_char4(simd_min(simd_make_char8_undef(x), simd_make_char8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_char8 simd_min(simd_char8 x, simd_char8 y) {
-#if defined __arm__ || defined __arm64__
-  return vmin_s8(x, y);
-#else
-  return simd_make_char8(simd_min(simd_make_char16_undef(x), simd_make_char16_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_char16 simd_min(simd_char16 x, simd_char16 y) {
-#if defined __arm__ || defined __arm64__
-  return vminq_s8(x, y);
-#elif defined __SSE4_1__
-  return _mm_min_epi8(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_char32 simd_min(simd_char32 x, simd_char32 y) {
-#if defined __AVX2__
-  return _mm256_min_epi8(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_char64 simd_min(simd_char64 x, simd_char64 y) {
-#if defined __AVX512BW__
-  return _mm512_min_epi8(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uchar2 simd_min(simd_uchar2 x, simd_uchar2 y) {
-  return simd_make_uchar2(simd_min(simd_make_uchar8_undef(x), simd_make_uchar8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uchar3 simd_min(simd_uchar3 x, simd_uchar3 y) {
-  return simd_make_uchar3(simd_min(simd_make_uchar8_undef(x), simd_make_uchar8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uchar4 simd_min(simd_uchar4 x, simd_uchar4 y) {
-  return simd_make_uchar4(simd_min(simd_make_uchar8_undef(x), simd_make_uchar8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uchar8 simd_min(simd_uchar8 x, simd_uchar8 y) {
-#if defined __arm__ || defined __arm64__
-  return vmin_u8(x, y);
-#else
-  return simd_make_uchar8(simd_min(simd_make_uchar16_undef(x), simd_make_uchar16_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_uchar16 simd_min(simd_uchar16 x, simd_uchar16 y) {
-#if defined __arm__ || defined __arm64__
-  return vminq_u8(x, y);
-#elif defined __SSE4_1__
-  return _mm_min_epu8(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uchar32 simd_min(simd_uchar32 x, simd_uchar32 y) {
-#if defined __AVX2__
-  return _mm256_min_epu8(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uchar64 simd_min(simd_uchar64 x, simd_uchar64 y) {
-#if defined __AVX512BW__
-  return _mm512_min_epu8(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_short2 simd_min(simd_short2 x, simd_short2 y) {
-  return simd_make_short2(simd_min(simd_make_short4_undef(x), simd_make_short4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_short3 simd_min(simd_short3 x, simd_short3 y) {
-  return simd_make_short3(simd_min(simd_make_short4_undef(x), simd_make_short4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_short4 simd_min(simd_short4 x, simd_short4 y) {
-#if defined __arm__ || defined __arm64__
-  return vmin_s16(x, y);
-#else
-  return simd_make_short4(simd_min(simd_make_short8_undef(x), simd_make_short8_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_short8 simd_min(simd_short8 x, simd_short8 y) {
-#if defined __arm__ || defined __arm64__
-  return vminq_s16(x, y);
-#elif defined __SSE4_1__
-  return _mm_min_epi16(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_short16 simd_min(simd_short16 x, simd_short16 y) {
-#if defined __AVX2__
-  return _mm256_min_epi16(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_short32 simd_min(simd_short32 x, simd_short32 y) {
-#if defined __AVX512BW__
-  return _mm512_min_epi16(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ushort2 simd_min(simd_ushort2 x, simd_ushort2 y) {
-  return simd_make_ushort2(simd_min(simd_make_ushort4_undef(x), simd_make_ushort4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_ushort3 simd_min(simd_ushort3 x, simd_ushort3 y) {
-  return simd_make_ushort3(simd_min(simd_make_ushort4_undef(x), simd_make_ushort4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_ushort4 simd_min(simd_ushort4 x, simd_ushort4 y) {
-#if defined __arm__ || defined __arm64__
-  return vmin_u16(x, y);
-#else
-  return simd_make_ushort4(simd_min(simd_make_ushort8_undef(x), simd_make_ushort8_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_ushort8 simd_min(simd_ushort8 x, simd_ushort8 y) {
-#if defined __arm__ || defined __arm64__
-  return vminq_u16(x, y);
-#elif defined __SSE4_1__
-  return _mm_min_epu16(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ushort16 simd_min(simd_ushort16 x, simd_ushort16 y) {
-#if defined __AVX2__
-  return _mm256_min_epu16(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ushort32 simd_min(simd_ushort32 x, simd_ushort32 y) {
-#if defined __AVX512BW__
-  return _mm512_min_epu16(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_int2 simd_min(simd_int2 x, simd_int2 y) {
-#if defined __arm__ || defined __arm64__
-  return vmin_s32(x, y);
-#else
-  return simd_make_int2(simd_min(simd_make_int4_undef(x), simd_make_int4_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_int3 simd_min(simd_int3 x, simd_int3 y) {
-  return simd_make_int3(simd_min(simd_make_int4_undef(x), simd_make_int4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_int4 simd_min(simd_int4 x, simd_int4 y) {
-#if defined __arm__ || defined __arm64__
-  return vminq_s32(x, y);
-#elif defined __SSE4_1__
-  return _mm_min_epi32(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_int8 simd_min(simd_int8 x, simd_int8 y) {
-#if defined __AVX2__
-  return _mm256_min_epi32(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_int16 simd_min(simd_int16 x, simd_int16 y) {
-#if defined __AVX512F__
-  return _mm512_min_epi32(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uint2 simd_min(simd_uint2 x, simd_uint2 y) {
-#if defined __arm__ || defined __arm64__
-  return vmin_u32(x, y);
-#else
-  return simd_make_uint2(simd_min(simd_make_uint4_undef(x), simd_make_uint4_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_uint3 simd_min(simd_uint3 x, simd_uint3 y) {
-  return simd_make_uint3(simd_min(simd_make_uint4_undef(x), simd_make_uint4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uint4 simd_min(simd_uint4 x, simd_uint4 y) {
-#if defined __arm__ || defined __arm64__
-  return vminq_u32(x, y);
-#elif defined __SSE4_1__
-  return _mm_min_epu32(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uint8 simd_min(simd_uint8 x, simd_uint8 y) {
-#if defined __AVX2__
-  return _mm256_min_epu32(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uint16 simd_min(simd_uint16 x, simd_uint16 y) {
-#if defined __AVX512F__
-  return _mm512_min_epu32(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC float simd_min(float x, float y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_float2 simd_min(simd_float2 x, simd_float2 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_min(simd_float3 x, simd_float3 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_min(simd_float4 x, simd_float4 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_min(simd_float8 x, simd_float8 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_min(simd_float16 x, simd_float16 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_long2 simd_min(simd_long2 x, simd_long2 y) {
-#if defined __AVX512VL__
-  return _mm_min_epi64(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_long3 simd_min(simd_long3 x, simd_long3 y) {
-  return simd_make_long3(simd_min(simd_make_long4_undef(x), simd_make_long4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_long4 simd_min(simd_long4 x, simd_long4 y) {
-#if defined __AVX512VL__
-  return _mm256_min_epi64(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_long8 simd_min(simd_long8 x, simd_long8 y) {
-#if defined __AVX512F__
-  return _mm512_min_epi64(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ulong2 simd_min(simd_ulong2 x, simd_ulong2 y) {
-#if defined __AVX512VL__
-  return _mm_min_epu64(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ulong3 simd_min(simd_ulong3 x, simd_ulong3 y) {
-  return simd_make_ulong3(simd_min(simd_make_ulong4_undef(x), simd_make_ulong4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_ulong4 simd_min(simd_ulong4 x, simd_ulong4 y) {
-#if defined __AVX512VL__
-  return _mm256_min_epu64(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ulong8 simd_min(simd_ulong8 x, simd_ulong8 y) {
-#if defined __AVX512F__
-  return _mm512_min_epu64(x, y);
-#else
-  return simd_bitselect(x, y, y < x);
-#endif
-}
-
-static inline SIMD_CFUNC double simd_min(double x, double y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_min(simd_double2 x, simd_double2 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_min(simd_double3 x, simd_double3 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_min(simd_double4 x, simd_double4 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_min(simd_double8 x, simd_double8 y) {
-  return __tg_fmin(x,y);
-}
-
-static inline SIMD_CFUNC simd_char2 simd_max(simd_char2 x, simd_char2 y) {
-  return simd_make_char2(simd_max(simd_make_char8_undef(x), simd_make_char8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_char3 simd_max(simd_char3 x, simd_char3 y) {
-  return simd_make_char3(simd_max(simd_make_char8_undef(x), simd_make_char8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_char4 simd_max(simd_char4 x, simd_char4 y) {
-  return simd_make_char4(simd_max(simd_make_char8_undef(x), simd_make_char8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_char8 simd_max(simd_char8 x, simd_char8 y) {
-#if defined __arm__ || defined __arm64__
-  return vmax_s8(x, y);
-#else
-  return simd_make_char8(simd_max(simd_make_char16_undef(x), simd_make_char16_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_char16 simd_max(simd_char16 x, simd_char16 y) {
-#if defined __arm__ || defined __arm64__
-  return vmaxq_s8(x, y);
-#elif defined __SSE4_1__
-  return _mm_max_epi8(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_char32 simd_max(simd_char32 x, simd_char32 y) {
-#if defined __AVX2__
-  return _mm256_max_epi8(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_char64 simd_max(simd_char64 x, simd_char64 y) {
-#if defined __AVX512BW__
-  return _mm512_max_epi8(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uchar2 simd_max(simd_uchar2 x, simd_uchar2 y) {
-  return simd_make_uchar2(simd_max(simd_make_uchar8_undef(x), simd_make_uchar8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uchar3 simd_max(simd_uchar3 x, simd_uchar3 y) {
-  return simd_make_uchar3(simd_max(simd_make_uchar8_undef(x), simd_make_uchar8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uchar4 simd_max(simd_uchar4 x, simd_uchar4 y) {
-  return simd_make_uchar4(simd_max(simd_make_uchar8_undef(x), simd_make_uchar8_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uchar8 simd_max(simd_uchar8 x, simd_uchar8 y) {
-#if defined __arm__ || defined __arm64__
-  return vmax_u8(x, y);
-#else
-  return simd_make_uchar8(simd_max(simd_make_uchar16_undef(x), simd_make_uchar16_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_uchar16 simd_max(simd_uchar16 x, simd_uchar16 y) {
-#if defined __arm__ || defined __arm64__
-  return vmaxq_u8(x, y);
-#elif defined __SSE4_1__
-  return _mm_max_epu8(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uchar32 simd_max(simd_uchar32 x, simd_uchar32 y) {
-#if defined __AVX2__
-  return _mm256_max_epu8(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uchar64 simd_max(simd_uchar64 x, simd_uchar64 y) {
-#if defined __AVX512BW__
-  return _mm512_max_epu8(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_short2 simd_max(simd_short2 x, simd_short2 y) {
-  return simd_make_short2(simd_max(simd_make_short4_undef(x), simd_make_short4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_short3 simd_max(simd_short3 x, simd_short3 y) {
-  return simd_make_short3(simd_max(simd_make_short4_undef(x), simd_make_short4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_short4 simd_max(simd_short4 x, simd_short4 y) {
-#if defined __arm__ || defined __arm64__
-  return vmax_s16(x, y);
-#else
-  return simd_make_short4(simd_max(simd_make_short8_undef(x), simd_make_short8_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_short8 simd_max(simd_short8 x, simd_short8 y) {
-#if defined __arm__ || defined __arm64__
-  return vmaxq_s16(x, y);
-#elif defined __SSE4_1__
-  return _mm_max_epi16(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_short16 simd_max(simd_short16 x, simd_short16 y) {
-#if defined __AVX2__
-  return _mm256_max_epi16(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_short32 simd_max(simd_short32 x, simd_short32 y) {
-#if defined __AVX512BW__
-  return _mm512_max_epi16(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ushort2 simd_max(simd_ushort2 x, simd_ushort2 y) {
-  return simd_make_ushort2(simd_max(simd_make_ushort4_undef(x), simd_make_ushort4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_ushort3 simd_max(simd_ushort3 x, simd_ushort3 y) {
-  return simd_make_ushort3(simd_max(simd_make_ushort4_undef(x), simd_make_ushort4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_ushort4 simd_max(simd_ushort4 x, simd_ushort4 y) {
-#if defined __arm__ || defined __arm64__
-  return vmax_u16(x, y);
-#else
-  return simd_make_ushort4(simd_max(simd_make_ushort8_undef(x), simd_make_ushort8_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_ushort8 simd_max(simd_ushort8 x, simd_ushort8 y) {
-#if defined __arm__ || defined __arm64__
-  return vmaxq_u16(x, y);
-#elif defined __SSE4_1__
-  return _mm_max_epu16(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ushort16 simd_max(simd_ushort16 x, simd_ushort16 y) {
-#if defined __AVX2__
-  return _mm256_max_epu16(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ushort32 simd_max(simd_ushort32 x, simd_ushort32 y) {
-#if defined __AVX512BW__
-  return _mm512_max_epu16(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_int2 simd_max(simd_int2 x, simd_int2 y) {
-#if defined __arm__ || defined __arm64__
-  return vmax_s32(x, y);
-#else
-  return simd_make_int2(simd_max(simd_make_int4_undef(x), simd_make_int4_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_int3 simd_max(simd_int3 x, simd_int3 y) {
-  return simd_make_int3(simd_max(simd_make_int4_undef(x), simd_make_int4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_int4 simd_max(simd_int4 x, simd_int4 y) {
-#if defined __arm__ || defined __arm64__
-  return vmaxq_s32(x, y);
-#elif defined __SSE4_1__
-  return _mm_max_epi32(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_int8 simd_max(simd_int8 x, simd_int8 y) {
-#if defined __AVX2__
-  return _mm256_max_epi32(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_int16 simd_max(simd_int16 x, simd_int16 y) {
-#if defined __AVX512F__
-  return _mm512_max_epi32(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uint2 simd_max(simd_uint2 x, simd_uint2 y) {
-#if defined __arm__ || defined __arm64__
-  return vmax_u32(x, y);
-#else
-  return simd_make_uint2(simd_max(simd_make_uint4_undef(x), simd_make_uint4_undef(y)));
-#endif
-
-}
-
-static inline SIMD_CFUNC simd_uint3 simd_max(simd_uint3 x, simd_uint3 y) {
-  return simd_make_uint3(simd_max(simd_make_uint4_undef(x), simd_make_uint4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_uint4 simd_max(simd_uint4 x, simd_uint4 y) {
-#if defined __arm__ || defined __arm64__
-  return vmaxq_u32(x, y);
-#elif defined __SSE4_1__
-  return _mm_max_epu32(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uint8 simd_max(simd_uint8 x, simd_uint8 y) {
-#if defined __AVX2__
-  return _mm256_max_epu32(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_uint16 simd_max(simd_uint16 x, simd_uint16 y) {
-#if defined __AVX512F__
-  return _mm512_max_epu32(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC float simd_max(float x, float y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_float2 simd_max(simd_float2 x, simd_float2 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_max(simd_float3 x, simd_float3 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_max(simd_float4 x, simd_float4 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_max(simd_float8 x, simd_float8 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_max(simd_float16 x, simd_float16 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_long2 simd_max(simd_long2 x, simd_long2 y) {
-#if defined __AVX512VL__
-  return _mm_max_epi64(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_long3 simd_max(simd_long3 x, simd_long3 y) {
-  return simd_make_long3(simd_max(simd_make_long4_undef(x), simd_make_long4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_long4 simd_max(simd_long4 x, simd_long4 y) {
-#if defined __AVX512VL__
-  return _mm256_max_epi64(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_long8 simd_max(simd_long8 x, simd_long8 y) {
-#if defined __AVX512F__
-  return _mm512_max_epi64(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ulong2 simd_max(simd_ulong2 x, simd_ulong2 y) {
-#if defined __AVX512VL__
-  return _mm_max_epu64(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ulong3 simd_max(simd_ulong3 x, simd_ulong3 y) {
-  return simd_make_ulong3(simd_max(simd_make_ulong4_undef(x), simd_make_ulong4_undef(y)));
-}
-
-static inline SIMD_CFUNC simd_ulong4 simd_max(simd_ulong4 x, simd_ulong4 y) {
-#if defined __AVX512VL__
-  return _mm256_max_epu64(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC simd_ulong8 simd_max(simd_ulong8 x, simd_ulong8 y) {
-#if defined __AVX512F__
-  return _mm512_max_epu64(x, y);
-#else
-  return simd_bitselect(x, y, x < y);
-#endif
-}
-
-static inline SIMD_CFUNC double simd_max(double x, double y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_max(simd_double2 x, simd_double2 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_max(simd_double3 x, simd_double3 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_max(simd_double4 x, simd_double4 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_max(simd_double8 x, simd_double8 y) {
-  return __tg_fmax(x,y);
-}
-
-static inline SIMD_CFUNC simd_char2 simd_clamp(simd_char2 x, simd_char2 min, simd_char2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_char3 simd_clamp(simd_char3 x, simd_char3 min, simd_char3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_char4 simd_clamp(simd_char4 x, simd_char4 min, simd_char4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_char8 simd_clamp(simd_char8 x, simd_char8 min, simd_char8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_char16 simd_clamp(simd_char16 x, simd_char16 min, simd_char16 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_char32 simd_clamp(simd_char32 x, simd_char32 min, simd_char32 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_char64 simd_clamp(simd_char64 x, simd_char64 min, simd_char64 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uchar2 simd_clamp(simd_uchar2 x, simd_uchar2 min, simd_uchar2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uchar3 simd_clamp(simd_uchar3 x, simd_uchar3 min, simd_uchar3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uchar4 simd_clamp(simd_uchar4 x, simd_uchar4 min, simd_uchar4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uchar8 simd_clamp(simd_uchar8 x, simd_uchar8 min, simd_uchar8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uchar16 simd_clamp(simd_uchar16 x, simd_uchar16 min, simd_uchar16 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uchar32 simd_clamp(simd_uchar32 x, simd_uchar32 min, simd_uchar32 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uchar64 simd_clamp(simd_uchar64 x, simd_uchar64 min, simd_uchar64 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_short2 simd_clamp(simd_short2 x, simd_short2 min, simd_short2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_short3 simd_clamp(simd_short3 x, simd_short3 min, simd_short3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_short4 simd_clamp(simd_short4 x, simd_short4 min, simd_short4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_short8 simd_clamp(simd_short8 x, simd_short8 min, simd_short8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_short16 simd_clamp(simd_short16 x, simd_short16 min, simd_short16 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_short32 simd_clamp(simd_short32 x, simd_short32 min, simd_short32 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ushort2 simd_clamp(simd_ushort2 x, simd_ushort2 min, simd_ushort2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ushort3 simd_clamp(simd_ushort3 x, simd_ushort3 min, simd_ushort3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ushort4 simd_clamp(simd_ushort4 x, simd_ushort4 min, simd_ushort4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ushort8 simd_clamp(simd_ushort8 x, simd_ushort8 min, simd_ushort8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ushort16 simd_clamp(simd_ushort16 x, simd_ushort16 min, simd_ushort16 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ushort32 simd_clamp(simd_ushort32 x, simd_ushort32 min, simd_ushort32 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_int2 simd_clamp(simd_int2 x, simd_int2 min, simd_int2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_int3 simd_clamp(simd_int3 x, simd_int3 min, simd_int3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_int4 simd_clamp(simd_int4 x, simd_int4 min, simd_int4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_int8 simd_clamp(simd_int8 x, simd_int8 min, simd_int8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_int16 simd_clamp(simd_int16 x, simd_int16 min, simd_int16 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uint2 simd_clamp(simd_uint2 x, simd_uint2 min, simd_uint2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uint3 simd_clamp(simd_uint3 x, simd_uint3 min, simd_uint3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uint4 simd_clamp(simd_uint4 x, simd_uint4 min, simd_uint4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uint8 simd_clamp(simd_uint8 x, simd_uint8 min, simd_uint8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_uint16 simd_clamp(simd_uint16 x, simd_uint16 min, simd_uint16 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC float simd_clamp(float x, float min, float max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_float2 simd_clamp(simd_float2 x, simd_float2 min, simd_float2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_clamp(simd_float3 x, simd_float3 min, simd_float3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_clamp(simd_float4 x, simd_float4 min, simd_float4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_clamp(simd_float8 x, simd_float8 min, simd_float8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_clamp(simd_float16 x, simd_float16 min, simd_float16 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_long2 simd_clamp(simd_long2 x, simd_long2 min, simd_long2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_long3 simd_clamp(simd_long3 x, simd_long3 min, simd_long3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_long4 simd_clamp(simd_long4 x, simd_long4 min, simd_long4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_long8 simd_clamp(simd_long8 x, simd_long8 min, simd_long8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ulong2 simd_clamp(simd_ulong2 x, simd_ulong2 min, simd_ulong2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ulong3 simd_clamp(simd_ulong3 x, simd_ulong3 min, simd_ulong3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ulong4 simd_clamp(simd_ulong4 x, simd_ulong4 min, simd_ulong4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_ulong8 simd_clamp(simd_ulong8 x, simd_ulong8 min, simd_ulong8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC double simd_clamp(double x, double min, double max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_clamp(simd_double2 x, simd_double2 min, simd_double2 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_clamp(simd_double3 x, simd_double3 min, simd_double3 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_clamp(simd_double4 x, simd_double4 min, simd_double4 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_clamp(simd_double8 x, simd_double8 min, simd_double8 max) {
-  return simd_min(simd_max(x, min), max);
-}
-
-  
-static inline SIMD_CFUNC float simd_sign(float x) {
-  return x == 0 | x != x ? 0 : copysign(1,x);
-}
-
-static inline SIMD_CFUNC simd_float2 simd_sign(simd_float2 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_sign(simd_float3 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_sign(simd_float4 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_sign(simd_float8 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_sign(simd_float16 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC double simd_sign(double x) {
-  return x == 0 | x != x ? 0 : copysign(1,x);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_sign(simd_double2 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_sign(simd_double3 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_sign(simd_double4 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_sign(simd_double8 x) {
-  return simd_bitselect(__tg_copysign(1,x), 0, x == 0 | x != x);
-}
-
-static inline SIMD_CFUNC float simd_mix(float x, float y, float t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_float2 simd_mix(simd_float2 x, simd_float2 y, simd_float2 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_float3 simd_mix(simd_float3 x, simd_float3 y, simd_float3 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_float4 simd_mix(simd_float4 x, simd_float4 y, simd_float4 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_float8 simd_mix(simd_float8 x, simd_float8 y, simd_float8 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_float16 simd_mix(simd_float16 x, simd_float16 y, simd_float16 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC double simd_mix(double x, double y, double t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_double2 simd_mix(simd_double2 x, simd_double2 y, simd_double2 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_double3 simd_mix(simd_double3 x, simd_double3 y, simd_double3 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_double4 simd_mix(simd_double4 x, simd_double4 y, simd_double4 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC simd_double8 simd_mix(simd_double8 x, simd_double8 y, simd_double8 t) {
-  return x + t*(y - x);
-}
-  
-static inline SIMD_CFUNC float simd_recip(float x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float2 simd_recip(simd_float2 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float3 simd_recip(simd_float3 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float4 simd_recip(simd_float4 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float8 simd_recip(simd_float8 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float16 simd_recip(simd_float16 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC double simd_recip(double x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_double2 simd_recip(simd_double2 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_double3 simd_recip(simd_double3 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_double4 simd_recip(simd_double4 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_double8 simd_recip(simd_double8 x) {
-#if __FAST_MATH__
-  return simd_fast_recip(x);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC float simd_fast_recip(float x) {
-#if defined __AVX512VL__
-  simd_float4 x4 = simd_make_float4(x);
-  return ((simd_float4)_mm_rcp14_ss(x4, x4)).x;
-#elif defined __SSE__
-  return ((simd_float4)_mm_rcp_ss(simd_make_float4(x))).x;
-#elif defined __ARM_NEON__
-  return simd_fast_recip(simd_make_float2_undef(x)).x;
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float2 simd_fast_recip(simd_float2 x) {
-#if defined __SSE__
-  return simd_make_float2(simd_fast_recip(simd_make_float4_undef(x)));
-#elif defined __ARM_NEON__
-  simd_float2 r = vrecpe_f32(x);
-  return r * vrecps_f32(x, r);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float3 simd_fast_recip(simd_float3 x) {
-  return simd_make_float3(simd_fast_recip(simd_make_float4_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_float4 simd_fast_recip(simd_float4 x) {
-#if defined __AVX512VL__
-  return _mm_rcp14_ps(x);
-#elif defined __SSE__
-  return _mm_rcp_ps(x);
-#elif defined __ARM_NEON__
-  simd_float4 r = vrecpeq_f32(x);
-  return r * vrecpsq_f32(x, r);
-#else
-  return simd_precise_recip(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float8 simd_fast_recip(simd_float8 x) {
-#if defined __AVX512VL__
-  return _mm256_rcp14_ps(x);
-#elif defined __AVX__
-  return _mm256_rcp_ps(x);
-#else
-  return simd_make_float8(simd_fast_recip(x.lo), simd_fast_recip(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_float16 simd_fast_recip(simd_float16 x) {
-#if defined __AVX512F__
-  return _mm512_rcp14_ps(x);
-#else
-  return simd_make_float16(simd_fast_recip(x.lo), simd_fast_recip(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC double simd_fast_recip(double x) {
-  return simd_precise_recip(x);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_fast_recip(simd_double2 x) {
-  return simd_precise_recip(x);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_fast_recip(simd_double3 x) {
-  return simd_precise_recip(x);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_fast_recip(simd_double4 x) {
-  return simd_precise_recip(x);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_fast_recip(simd_double8 x) {
-  return simd_precise_recip(x);
-}
-
-static inline SIMD_CFUNC float simd_precise_recip(float x) {
-#if defined __SSE__
-  float r = simd_fast_recip(x);
-  return r*(2 - (x == 0 ? -INFINITY : x)*r);
-#elif defined __ARM_NEON__
-  return simd_precise_recip(simd_make_float2_undef(x)).x;
-#else
-  return 1/x;
-#endif
-}
-
-static inline SIMD_CFUNC simd_float2 simd_precise_recip(simd_float2 x) {
-#if defined __SSE__
-  return simd_make_float2(simd_precise_recip(simd_make_float4_undef(x)));
-#elif defined __ARM_NEON__
-  simd_float2 r = simd_fast_recip(x);
-  return r*vrecps_f32(x, r);
-#else
-  return 1/x;
-#endif
-}
-
-static inline SIMD_CFUNC simd_float3 simd_precise_recip(simd_float3 x) {
-  return simd_make_float3(simd_precise_recip(simd_make_float4_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_float4 simd_precise_recip(simd_float4 x) {
-#if defined __SSE__
-  simd_float4 r = simd_fast_recip(x);
-  return r*(2 - simd_bitselect(x, -INFINITY, x == 0)*r);
-#elif defined __ARM_NEON__
-  simd_float4 r = simd_fast_recip(x);
-  return r*vrecpsq_f32(x, r);
-#else
-  return 1/x;
-#endif
-}
-
-static inline SIMD_CFUNC simd_float8 simd_precise_recip(simd_float8 x) {
-#if defined __AVX__
-  simd_float8 r = simd_fast_recip(x);
-  return r*(2 - simd_bitselect(x, -INFINITY, x == 0)*r);
-#else
-  return simd_make_float8(simd_precise_recip(x.lo), simd_precise_recip(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_float16 simd_precise_recip(simd_float16 x) {
-#if defined __AVX512F__
-  simd_float16 r = simd_fast_recip(x);
-  return r*(2 - simd_bitselect(x, -INFINITY, x == 0)*r);
-#else
-  return simd_make_float16(simd_precise_recip(x.lo), simd_precise_recip(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC double simd_precise_recip(double x) {
-  return 1/x;
-}
-
-static inline SIMD_CFUNC simd_double2 simd_precise_recip(simd_double2 x) {
-  return 1/x;
-}
-
-static inline SIMD_CFUNC simd_double3 simd_precise_recip(simd_double3 x) {
-  return 1/x;
-}
-
-static inline SIMD_CFUNC simd_double4 simd_precise_recip(simd_double4 x) {
-  return 1/x;
-}
-
-static inline SIMD_CFUNC simd_double8 simd_precise_recip(simd_double8 x) {
-  return 1/x;
-}
-
-static inline SIMD_CFUNC float simd_rsqrt(float x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float2 simd_rsqrt(simd_float2 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float3 simd_rsqrt(simd_float3 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float4 simd_rsqrt(simd_float4 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float8 simd_rsqrt(simd_float8 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float16 simd_rsqrt(simd_float16 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC double simd_rsqrt(double x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_double2 simd_rsqrt(simd_double2 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_double3 simd_rsqrt(simd_double3 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_double4 simd_rsqrt(simd_double4 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_double8 simd_rsqrt(simd_double8 x) {
-#if __FAST_MATH__
-  return simd_fast_rsqrt(x);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC float simd_fast_rsqrt(float x) {
-#if defined __AVX512VL__
-  simd_float4 x4 = simd_make_float4(x);
-  return ((simd_float4)_mm_rsqrt14_ss(x4, x4)).x;
-#elif defined __SSE__
-  return ((simd_float4)_mm_rsqrt_ss(simd_make_float4(x))).x;
-#elif defined __ARM_NEON__
-  return simd_fast_rsqrt(simd_make_float2_undef(x)).x;
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float2 simd_fast_rsqrt(simd_float2 x) {
-#if defined __SSE__
-  return simd_make_float2(simd_fast_rsqrt(simd_make_float4_undef(x)));
-#elif defined __ARM_NEON__
-  simd_float2 r = vrsqrte_f32(x);
-  return r * vrsqrts_f32(x, r*r);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float3 simd_fast_rsqrt(simd_float3 x) {
-  return simd_make_float3(simd_fast_rsqrt(simd_make_float4_undef(x)));
-}
-
-static inline SIMD_CFUNC simd_float4 simd_fast_rsqrt(simd_float4 x) {
-#if defined __AVX512VL__
-  return _mm_rsqrt14_ps(x);
-#elif defined __SSE__
-  return _mm_rsqrt_ps(x);
-#elif defined __ARM_NEON__
-  simd_float4 r = vrsqrteq_f32(x);
-  return r * vrsqrtsq_f32(x, r*r);
-#else
-  return simd_precise_rsqrt(x);
-#endif
-}
-
-static inline SIMD_CFUNC simd_float8 simd_fast_rsqrt(simd_float8 x) {
-#if defined __AVX512VL__
-  return _mm256_rsqrt14_ps(x);
-#elif defined __AVX__
-  return _mm256_rsqrt_ps(x);
-#else
-  return simd_make_float8(simd_fast_rsqrt(x.lo), simd_fast_rsqrt(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC simd_float16 simd_fast_rsqrt(simd_float16 x) {
-#if defined __AVX512F__
-  return _mm512_rsqrt14_ps(x);
-#else
-  return simd_make_float16(simd_fast_rsqrt(x.lo), simd_fast_rsqrt(x.hi));
-#endif
-}
-
-static inline SIMD_CFUNC double simd_fast_rsqrt(double x) {
-  return simd_precise_rsqrt(x);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_fast_rsqrt(simd_double2 x) {
-  return simd_precise_rsqrt(x);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_fast_rsqrt(simd_double3 x) {
-  return simd_precise_rsqrt(x);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_fast_rsqrt(simd_double4 x) {
-  return simd_precise_rsqrt(x);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_fast_rsqrt(simd_double8 x) {
-  return simd_precise_rsqrt(x);
-}
-
-static inline SIMD_CFUNC float simd_precise_rsqrt(float x) {
-#if defined __SSE__
-  float r = simd_fast_rsqrt(x);
-  return r*(1.5f - 0.5f*(r == INFINITY ? -INFINITY : x)*r*r);
-#elif defined __ARM_NEON__
-  return simd_precise_rsqrt(simd_make_float2_undef(x)).x;
-#else
-  return 1/sqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float2 simd_precise_rsqrt(simd_float2 x) {
-#if defined __SSE__
-  return simd_make_float2(simd_precise_rsqrt(simd_make_float4_undef(x)));
-#elif defined __ARM_NEON__
-  simd_float2 r = simd_fast_rsqrt(x);
-  return r*vrsqrts_f32(x, r*r);
-#else
-  return 1/__tg_sqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float3 simd_precise_rsqrt(simd_float3 x) {
-  return simd_make_float3(simd_precise_rsqrt(simd_make_float4_undef(x)));
-}
-  
-static inline SIMD_CFUNC simd_float4 simd_precise_rsqrt(simd_float4 x) {
-#if defined __SSE__
-  simd_float4 r = simd_fast_rsqrt(x);
-  return r*(1.5 - 0.5*simd_bitselect(x, -INFINITY, r == INFINITY)*r*r);
-#elif defined __ARM_NEON__
-  simd_float4 r = simd_fast_rsqrt(x);
-  return r*vrsqrtsq_f32(x, r*r);
-#else
-  return 1/__tg_sqrt(x);
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float8 simd_precise_rsqrt(simd_float8 x) {
-#if defined __AVX__
-  simd_float8 r = simd_fast_rsqrt(x);
-  return r*(1.5 - 0.5*simd_bitselect(x, -INFINITY, r == INFINITY)*r*r);
-#else
-  return simd_make_float8(simd_precise_rsqrt(x.lo), simd_precise_rsqrt(x.hi));
-#endif
-}
-  
-static inline SIMD_CFUNC simd_float16 simd_precise_rsqrt(simd_float16 x) {
-#if defined __AVX512F__
-  simd_float16 r = simd_fast_rsqrt(x);
-  return r*(1.5 - 0.5*simd_bitselect(x, -INFINITY, r == INFINITY)*r*r);
-#else
-  return simd_make_float16(simd_precise_rsqrt(x.lo), simd_precise_rsqrt(x.hi));
-#endif
-}
-  
-static inline SIMD_CFUNC double simd_precise_rsqrt(double x) {
-  return 1/sqrt(x);
-}
-  
-static inline SIMD_CFUNC simd_double2 simd_precise_rsqrt(simd_double2 x) {
-  return 1/__tg_sqrt(x);
-}
-  
-static inline SIMD_CFUNC simd_double3 simd_precise_rsqrt(simd_double3 x) {
-  return 1/__tg_sqrt(x);
-}
-  
-static inline SIMD_CFUNC simd_double4 simd_precise_rsqrt(simd_double4 x) {
-  return 1/__tg_sqrt(x);
-}
-  
-static inline SIMD_CFUNC simd_double8 simd_precise_rsqrt(simd_double8 x) {
-  return 1/__tg_sqrt(x);
-}
-  
-static inline SIMD_CFUNC float simd_fract(float x) {
-  return fmin(x - floor(x), 0x1.fffffep-1f);
-}
-
-static inline SIMD_CFUNC simd_float2 simd_fract(simd_float2 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffep-1f);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_fract(simd_float3 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffep-1f);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_fract(simd_float4 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffep-1f);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_fract(simd_float8 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffep-1f);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_fract(simd_float16 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffep-1f);
-}
-
-static inline SIMD_CFUNC double simd_fract(double x) {
-  return fmin(x - floor(x), 0x1.fffffffffffffp-1);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_fract(simd_double2 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffffffffffp-1);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_fract(simd_double3 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffffffffffp-1);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_fract(simd_double4 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffffffffffp-1);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_fract(simd_double8 x) {
-  return __tg_fmin(x - __tg_floor(x), 0x1.fffffffffffffp-1);
-}
-
-static inline SIMD_CFUNC float simd_step(float edge, float x) {
-  return !(x < edge);
-}
-
-static inline SIMD_CFUNC simd_float2 simd_step(simd_float2 edge, simd_float2 x) {
-  return simd_bitselect((simd_float2)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_step(simd_float3 edge, simd_float3 x) {
-  return simd_bitselect((simd_float3)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_step(simd_float4 edge, simd_float4 x) {
-  return simd_bitselect((simd_float4)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_step(simd_float8 edge, simd_float8 x) {
-  return simd_bitselect((simd_float8)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_step(simd_float16 edge, simd_float16 x) {
-  return simd_bitselect((simd_float16)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC double simd_step(double edge, double x) {
-  return !(x < edge);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_step(simd_double2 edge, simd_double2 x) {
-  return simd_bitselect((simd_double2)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_step(simd_double3 edge, simd_double3 x) {
-  return simd_bitselect((simd_double3)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_step(simd_double4 edge, simd_double4 x) {
-  return simd_bitselect((simd_double4)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_step(simd_double8 edge, simd_double8 x) {
-  return simd_bitselect((simd_double8)1, 0, x < edge);
-}
-
-static inline SIMD_CFUNC float simd_smoothstep(float edge0, float edge1, float x) {
-  float t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_float2 simd_smoothstep(simd_float2 edge0, simd_float2 edge1, simd_float2 x) {
-  simd_float2 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_float3 simd_smoothstep(simd_float3 edge0, simd_float3 edge1, simd_float3 x) {
-  simd_float3 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_float4 simd_smoothstep(simd_float4 edge0, simd_float4 edge1, simd_float4 x) {
-  simd_float4 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_float8 simd_smoothstep(simd_float8 edge0, simd_float8 edge1, simd_float8 x) {
-  simd_float8 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_float16 simd_smoothstep(simd_float16 edge0, simd_float16 edge1, simd_float16 x) {
-  simd_float16 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC double simd_smoothstep(double edge0, double edge1, double x) {
-  double t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_double2 simd_smoothstep(simd_double2 edge0, simd_double2 edge1, simd_double2 x) {
-  simd_double2 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_double3 simd_smoothstep(simd_double3 edge0, simd_double3 edge1, simd_double3 x) {
-  simd_double3 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_double4 simd_smoothstep(simd_double4 edge0, simd_double4 edge1, simd_double4 x) {
-  simd_double4 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC simd_double8 simd_smoothstep(simd_double8 edge0, simd_double8 edge1, simd_double8 x) {
-  simd_double8 t = simd_clamp((x - edge0)/(edge1 - edge0), 0, 1);
-  return t*t*(3 - 2*t);
-}
-
-static inline SIMD_CFUNC char simd_reduce_add(simd_char2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC char simd_reduce_add(simd_char3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC char simd_reduce_add(simd_char4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC char simd_reduce_add(simd_char8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC char simd_reduce_add(simd_char16 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC char simd_reduce_add(simd_char32 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC char simd_reduce_add(simd_char64 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar16 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar32 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_add(simd_uchar64 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC short simd_reduce_add(simd_short2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC short simd_reduce_add(simd_short3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC short simd_reduce_add(simd_short4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC short simd_reduce_add(simd_short8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC short simd_reduce_add(simd_short16 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC short simd_reduce_add(simd_short32 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort16 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_add(simd_ushort32 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC int simd_reduce_add(simd_int2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC int simd_reduce_add(simd_int3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC int simd_reduce_add(simd_int4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC int simd_reduce_add(simd_int8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC int simd_reduce_add(simd_int16 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_add(simd_uint16 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC float simd_reduce_add(simd_float2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC float simd_reduce_add(simd_float3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC float simd_reduce_add(simd_float4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC float simd_reduce_add(simd_float8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC float simd_reduce_add(simd_float16 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_add(simd_long8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_add(simd_ulong8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC double simd_reduce_add(simd_double2 x) {
-  return x.x + x.y;
-}
-
-static inline SIMD_CFUNC double simd_reduce_add(simd_double3 x) {
-  return x.x + x.y + x.z;
-}
-
-static inline SIMD_CFUNC double simd_reduce_add(simd_double4 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC double simd_reduce_add(simd_double8 x) {
-  return simd_reduce_add(x.lo + x.hi);
-}
-
-static inline SIMD_CFUNC char simd_reduce_min(simd_char2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC char simd_reduce_min(simd_char3 x) {
-  char t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC char simd_reduce_min(simd_char4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_min(simd_char8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_min(simd_char16 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_min(simd_char32 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_min(simd_char64 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar3 x) {
-  unsigned char t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar16 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar32 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_min(simd_uchar64 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_min(simd_short2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC short simd_reduce_min(simd_short3 x) {
-  short t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC short simd_reduce_min(simd_short4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_min(simd_short8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_min(simd_short16 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_min(simd_short32 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort3 x) {
-  unsigned short t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort16 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_min(simd_ushort32 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC int simd_reduce_min(simd_int2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC int simd_reduce_min(simd_int3 x) {
-  int t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC int simd_reduce_min(simd_int4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC int simd_reduce_min(simd_int8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC int simd_reduce_min(simd_int16 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint3 x) {
-  unsigned int t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_min(simd_uint16 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC float simd_reduce_min(simd_float2 x) {
-  return fmin(x.x, x.y);
-}
-
-static inline SIMD_CFUNC float simd_reduce_min(simd_float3 x) {
-  return fmin(fmin(x.x, x.z), x.y);
-}
-
-static inline SIMD_CFUNC float simd_reduce_min(simd_float4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC float simd_reduce_min(simd_float8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC float simd_reduce_min(simd_float16 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long3 x) {
-  simd_long1 t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_min(simd_long8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong2 x) {
-  return x.y < x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong3 x) {
-  simd_ulong1 t = x.z < x.x ? x.z : x.x;
-  return x.y < t ? x.y : t;
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_min(simd_ulong8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC double simd_reduce_min(simd_double2 x) {
-  return fmin(x.x, x.y);
-}
-
-static inline SIMD_CFUNC double simd_reduce_min(simd_double3 x) {
-  return fmin(fmin(x.x, x.z), x.y);
-}
-
-static inline SIMD_CFUNC double simd_reduce_min(simd_double4 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC double simd_reduce_min(simd_double8 x) {
-  return simd_reduce_min(simd_min(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_max(simd_char2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC char simd_reduce_max(simd_char3 x) {
-  char t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC char simd_reduce_max(simd_char4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_max(simd_char8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_max(simd_char16 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_max(simd_char32 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC char simd_reduce_max(simd_char64 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar3 x) {
-  unsigned char t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar16 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar32 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned char simd_reduce_max(simd_uchar64 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_max(simd_short2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC short simd_reduce_max(simd_short3 x) {
-  short t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC short simd_reduce_max(simd_short4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_max(simd_short8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_max(simd_short16 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC short simd_reduce_max(simd_short32 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort3 x) {
-  unsigned short t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort16 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned short simd_reduce_max(simd_ushort32 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC int simd_reduce_max(simd_int2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC int simd_reduce_max(simd_int3 x) {
-  int t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC int simd_reduce_max(simd_int4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC int simd_reduce_max(simd_int8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC int simd_reduce_max(simd_int16 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint3 x) {
-  unsigned int t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC unsigned int simd_reduce_max(simd_uint16 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC float simd_reduce_max(simd_float2 x) {
-  return fmax(x.x, x.y);
-}
-
-static inline SIMD_CFUNC float simd_reduce_max(simd_float3 x) {
-  return fmax(fmax(x.x, x.z), x.y);
-}
-
-static inline SIMD_CFUNC float simd_reduce_max(simd_float4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC float simd_reduce_max(simd_float8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC float simd_reduce_max(simd_float16 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long3 x) {
-  simd_long1 t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_long1 simd_reduce_max(simd_long8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong2 x) {
-  return x.y > x.x ? x.y : x.x;
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong3 x) {
-  simd_ulong1 t = x.z > x.x ? x.z : x.x;
-  return x.y > t ? x.y : t;
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC simd_ulong1 simd_reduce_max(simd_ulong8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC double simd_reduce_max(simd_double2 x) {
-  return fmax(x.x, x.y);
-}
-
-static inline SIMD_CFUNC double simd_reduce_max(simd_double3 x) {
-  return fmax(fmax(x.x, x.z), x.y);
-}
-
-static inline SIMD_CFUNC double simd_reduce_max(simd_double4 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-static inline SIMD_CFUNC double simd_reduce_max(simd_double8 x) {
-  return simd_reduce_max(simd_max(x.lo, x.hi));
-}
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */
-#endif /* SIMD_COMMON_HEADER */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/simd/conversion.h b/lib/libc/include/x86_64-macos.10-none/simd/conversion.h
deleted file mode 100644
index cc6c533e8f..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/simd/conversion.h
+++ /dev/null
@@ -1,1876 +0,0 @@
-/*  Copyright (c) 2014-2017 Apple, Inc. All rights reserved.
- *
- *  The interfaces declared in this header provide conversions between vector
- *  types. The following functions are available:
- *
- *      simd_char(x)      simd_uchar(x)
- *      simd_short(x)     simd_ushort(x)
- *      simd_int(x)       simd_uint(x)
- *      simd_long(x)      simd_ulong(x)
- *      simd_float(x)
- *      simd_double(x)
- *
- *  Each of these functions converts x to a vector whose elements have the
- *  type named by the function, with the same number of elements as x. Unlike
- *  a vector cast, these functions convert the elements to the new element
- *  type. These conversions behave exactly as C scalar conversions, except
- *  that conversions from integer vector types to signed integer vector types
- *  are guaranteed to wrap modulo 2^N (where N is the number of bits in an
- *  element of the result type).
- *
- *  For integer vector types, saturating conversions are also available:
- *
- *      simd_char_sat(x)      simd_uchar_sat(x)
- *      simd_short_sat(x)     simd_ushort_sat(x)
- *      simd_int_sat(x)       simd_uint_sat(x)
- *      simd_long_sat(x)      simd_ulong_sat(x)
- *
- *  These conversions clamp x to the representable range of the result type
- *  before converting.
- *
- *  Unlike most vector operations in <simd/>, there are no abbreviated C++
- *  names for these functions in the simd:: namespace.
- */
-
-#ifndef __SIMD_CONVERSION_HEADER__
-#define __SIMD_CONVERSION_HEADER__
-
-#include <simd/base.h>
-#if SIMD_COMPILER_HAS_REQUIRED_FEATURES
-#include <simd/vector_types.h>
-#include <simd/common.h>
-#include <simd/logic.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-static simd_char2  SIMD_CFUNC simd_char(simd_char2    __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_char3    __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_char4    __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_char8    __x);
-static simd_char16 SIMD_CFUNC simd_char(simd_char16   __x);
-static simd_char32 SIMD_CFUNC simd_char(simd_char32   __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_uchar2   __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_uchar3   __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_uchar4   __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_uchar8   __x);
-static simd_char16 SIMD_CFUNC simd_char(simd_uchar16  __x);
-static simd_char32 SIMD_CFUNC simd_char(simd_uchar32  __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_short2   __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_short3   __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_short4   __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_short8   __x);
-static simd_char16 SIMD_CFUNC simd_char(simd_short16  __x);
-static simd_char32 SIMD_CFUNC simd_char(simd_short32  __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_ushort2  __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_ushort3  __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_ushort4  __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_ushort8  __x);
-static simd_char16 SIMD_CFUNC simd_char(simd_ushort16 __x);
-static simd_char32 SIMD_CFUNC simd_char(simd_ushort32 __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_int2     __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_int3     __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_int4     __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_int8     __x);
-static simd_char16 SIMD_CFUNC simd_char(simd_int16    __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_uint2    __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_uint3    __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_uint4    __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_uint8    __x);
-static simd_char16 SIMD_CFUNC simd_char(simd_uint16   __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_float2   __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_float3   __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_float4   __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_float8   __x);
-static simd_char16 SIMD_CFUNC simd_char(simd_float16  __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_long2    __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_long3    __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_long4    __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_long8    __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_ulong2   __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_ulong3   __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_ulong4   __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_ulong8   __x);
-static simd_char2  SIMD_CFUNC simd_char(simd_double2  __x);
-static simd_char3  SIMD_CFUNC simd_char(simd_double3  __x);
-static simd_char4  SIMD_CFUNC simd_char(simd_double4  __x);
-static simd_char8  SIMD_CFUNC simd_char(simd_double8  __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_char2    __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_char3    __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_char4    __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_char8    __x);
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_char16   __x);
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_char32   __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_short2   __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_short3   __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_short4   __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_short8   __x);
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_short16  __x);
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_short32  __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_int2     __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_int3     __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_int4     __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_int8     __x);
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_int16    __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_float2   __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_float3   __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_float4   __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_float8   __x);
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_float16  __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_long2    __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_long3    __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_long4    __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_long8    __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_double2  __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_double3  __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_double4  __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_double8  __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_uchar2   __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_uchar3   __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_uchar4   __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_uchar8   __x);
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_uchar16  __x);
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_uchar32  __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_ushort2  __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_ushort3  __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_ushort4  __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_ushort8  __x);
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_ushort16 __x);
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_ushort32 __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_uint2    __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_uint3    __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_uint4    __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_uint8    __x);
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_uint16   __x);
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_ulong2   __x);
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_ulong3   __x);
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_ulong4   __x);
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_ulong8   __x);
-#define vector_char simd_char
-#define vector_char_sat simd_char_sat
-
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_char2    __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_char3    __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_char4    __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_char8    __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_char16   __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_char32   __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_uchar2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_uchar3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_uchar4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_uchar8   __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_uchar16  __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_uchar32  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_short2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_short3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_short4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_short8   __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_short16  __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_short32  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_ushort2  __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_ushort3  __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_ushort4  __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_ushort8  __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_ushort16 __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_ushort32 __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_int2     __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_int3     __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_int4     __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_int8     __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_int16    __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_uint2    __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_uint3    __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_uint4    __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_uint8    __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_uint16   __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_float2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_float3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_float4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_float8   __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_float16  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_long2    __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_long3    __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_long4    __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_long8    __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_ulong2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_ulong3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_ulong4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_ulong8   __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_double2  __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_double3  __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_double4  __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_double8  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_char2    __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_char3    __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_char4    __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_char8    __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_char16   __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_char32   __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_short2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_short3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_short4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_short8   __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_short16  __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_short32  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_int2     __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_int3     __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_int4     __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_int8     __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_int16    __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_float2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_float3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_float4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_float8   __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_float16  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_long2    __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_long3    __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_long4    __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_long8    __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_double2  __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_double3  __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_double4  __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_double8  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_uchar2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_uchar3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_uchar4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_uchar8   __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_uchar16  __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_uchar32  __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_ushort2  __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_ushort3  __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_ushort4  __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_ushort8  __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_ushort16 __x);
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_ushort32 __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_uint2    __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_uint3    __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_uint4    __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_uint8    __x);
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_uint16   __x);
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_ulong2   __x);
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_ulong3   __x);
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_ulong4   __x);
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_ulong8   __x);
-#define vector_uchar simd_uchar
-#define vector_uchar_sat simd_uchar_sat
-
-static simd_short2  SIMD_CFUNC simd_short(simd_char2    __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_char3    __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_char4    __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_char8    __x);
-static simd_short16 SIMD_CFUNC simd_short(simd_char16   __x);
-static simd_short32 SIMD_CFUNC simd_short(simd_char32   __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_uchar2   __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_uchar3   __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_uchar4   __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_uchar8   __x);
-static simd_short16 SIMD_CFUNC simd_short(simd_uchar16  __x);
-static simd_short32 SIMD_CFUNC simd_short(simd_uchar32  __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_short2   __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_short3   __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_short4   __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_short8   __x);
-static simd_short16 SIMD_CFUNC simd_short(simd_short16  __x);
-static simd_short32 SIMD_CFUNC simd_short(simd_short32  __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_ushort2  __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_ushort3  __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_ushort4  __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_ushort8  __x);
-static simd_short16 SIMD_CFUNC simd_short(simd_ushort16 __x);
-static simd_short32 SIMD_CFUNC simd_short(simd_ushort32 __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_int2     __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_int3     __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_int4     __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_int8     __x);
-static simd_short16 SIMD_CFUNC simd_short(simd_int16    __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_uint2    __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_uint3    __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_uint4    __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_uint8    __x);
-static simd_short16 SIMD_CFUNC simd_short(simd_uint16   __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_float2   __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_float3   __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_float4   __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_float8   __x);
-static simd_short16 SIMD_CFUNC simd_short(simd_float16  __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_long2    __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_long3    __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_long4    __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_long8    __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_ulong2   __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_ulong3   __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_ulong4   __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_ulong8   __x);
-static simd_short2  SIMD_CFUNC simd_short(simd_double2  __x);
-static simd_short3  SIMD_CFUNC simd_short(simd_double3  __x);
-static simd_short4  SIMD_CFUNC simd_short(simd_double4  __x);
-static simd_short8  SIMD_CFUNC simd_short(simd_double8  __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_char2    __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_char3    __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_char4    __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_char8    __x);
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_char16   __x);
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_char32   __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_short2   __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_short3   __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_short4   __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_short8   __x);
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_short16  __x);
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_short32  __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_int2     __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_int3     __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_int4     __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_int8     __x);
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_int16    __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_float2   __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_float3   __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_float4   __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_float8   __x);
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_float16  __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_long2    __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_long3    __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_long4    __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_long8    __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_double2  __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_double3  __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_double4  __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_double8  __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_uchar2   __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_uchar3   __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_uchar4   __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_uchar8   __x);
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_uchar16  __x);
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_uchar32  __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_ushort2  __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_ushort3  __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_ushort4  __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_ushort8  __x);
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_ushort16 __x);
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_ushort32 __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_uint2    __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_uint3    __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_uint4    __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_uint8    __x);
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_uint16   __x);
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_ulong2   __x);
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_ulong3   __x);
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_ulong4   __x);
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_ulong8   __x);
-#define vector_short simd_short
-#define vector_short_sat simd_short_sat
-
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_char2    __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_char3    __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_char4    __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_char8    __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_char16   __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_char32   __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_uchar2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_uchar3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_uchar4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_uchar8   __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_uchar16  __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_uchar32  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_short2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_short3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_short4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_short8   __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_short16  __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_short32  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_ushort2  __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_ushort3  __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_ushort4  __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_ushort8  __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_ushort16 __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_ushort32 __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_int2     __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_int3     __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_int4     __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_int8     __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_int16    __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_uint2    __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_uint3    __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_uint4    __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_uint8    __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_uint16   __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_float2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_float3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_float4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_float8   __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_float16  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_long2    __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_long3    __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_long4    __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_long8    __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_ulong2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_ulong3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_ulong4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_ulong8   __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_double2  __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_double3  __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_double4  __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_double8  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_char2    __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_char3    __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_char4    __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_char8    __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_char16   __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_char32   __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_short2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_short3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_short4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_short8   __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_short16  __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_short32  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_int2     __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_int3     __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_int4     __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_int8     __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_int16    __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_float2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_float3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_float4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_float8   __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_float16  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_long2    __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_long3    __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_long4    __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_long8    __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_double2  __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_double3  __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_double4  __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_double8  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_uchar2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_uchar3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_uchar4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_uchar8   __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_uchar16  __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_uchar32  __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_ushort2  __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_ushort3  __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_ushort4  __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_ushort8  __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_ushort16 __x);
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_ushort32 __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_uint2    __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_uint3    __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_uint4    __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_uint8    __x);
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_uint16   __x);
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_ulong2   __x);
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_ulong3   __x);
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_ulong4   __x);
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_ulong8   __x);
-#define vector_ushort simd_ushort
-#define vector_ushort_sat simd_ushort_sat
-
-static simd_int2  SIMD_CFUNC simd_int(simd_char2    __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_char3    __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_char4    __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_char8    __x);
-static simd_int16 SIMD_CFUNC simd_int(simd_char16   __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_uchar2   __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_uchar3   __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_uchar4   __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_uchar8   __x);
-static simd_int16 SIMD_CFUNC simd_int(simd_uchar16  __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_short2   __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_short3   __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_short4   __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_short8   __x);
-static simd_int16 SIMD_CFUNC simd_int(simd_short16  __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_ushort2  __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_ushort3  __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_ushort4  __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_ushort8  __x);
-static simd_int16 SIMD_CFUNC simd_int(simd_ushort16 __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_int2     __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_int3     __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_int4     __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_int8     __x);
-static simd_int16 SIMD_CFUNC simd_int(simd_int16    __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_uint2    __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_uint3    __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_uint4    __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_uint8    __x);
-static simd_int16 SIMD_CFUNC simd_int(simd_uint16   __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_float2   __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_float3   __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_float4   __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_float8   __x);
-static simd_int16 SIMD_CFUNC simd_int(simd_float16  __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_long2    __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_long3    __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_long4    __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_long8    __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_ulong2   __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_ulong3   __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_ulong4   __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_ulong8   __x);
-static simd_int2  SIMD_CFUNC simd_int(simd_double2  __x);
-static simd_int3  SIMD_CFUNC simd_int(simd_double3  __x);
-static simd_int4  SIMD_CFUNC simd_int(simd_double4  __x);
-static simd_int8  SIMD_CFUNC simd_int(simd_double8  __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_char2    __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_char3    __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_char4    __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_char8    __x);
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_char16   __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_short2   __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_short3   __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_short4   __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_short8   __x);
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_short16  __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_int2     __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_int3     __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_int4     __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_int8     __x);
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_int16    __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_float2   __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_float3   __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_float4   __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_float8   __x);
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_float16  __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_long2    __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_long3    __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_long4    __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_long8    __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_double2  __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_double3  __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_double4  __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_double8  __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_uchar2   __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_uchar3   __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_uchar4   __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_uchar8   __x);
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_uchar16  __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_ushort2  __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_ushort3  __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_ushort4  __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_ushort8  __x);
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_ushort16 __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_uint2    __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_uint3    __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_uint4    __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_uint8    __x);
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_uint16   __x);
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_ulong2   __x);
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_ulong3   __x);
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_ulong4   __x);
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_ulong8   __x);
-#define vector_int simd_int
-#define vector_int_sat simd_int_sat
-
-static simd_uint2  SIMD_CFUNC simd_uint(simd_char2    __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_char3    __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_char4    __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_char8    __x);
-static simd_uint16 SIMD_CFUNC simd_uint(simd_char16   __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_uchar2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_uchar3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_uchar4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_uchar8   __x);
-static simd_uint16 SIMD_CFUNC simd_uint(simd_uchar16  __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_short2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_short3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_short4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_short8   __x);
-static simd_uint16 SIMD_CFUNC simd_uint(simd_short16  __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_ushort2  __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_ushort3  __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_ushort4  __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_ushort8  __x);
-static simd_uint16 SIMD_CFUNC simd_uint(simd_ushort16 __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_int2     __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_int3     __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_int4     __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_int8     __x);
-static simd_uint16 SIMD_CFUNC simd_uint(simd_int16    __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_uint2    __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_uint3    __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_uint4    __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_uint8    __x);
-static simd_uint16 SIMD_CFUNC simd_uint(simd_uint16   __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_float2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_float3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_float4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_float8   __x);
-static simd_uint16 SIMD_CFUNC simd_uint(simd_float16  __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_long2    __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_long3    __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_long4    __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_long8    __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_ulong2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_ulong3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_ulong4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_ulong8   __x);
-static simd_uint2  SIMD_CFUNC simd_uint(simd_double2  __x);
-static simd_uint3  SIMD_CFUNC simd_uint(simd_double3  __x);
-static simd_uint4  SIMD_CFUNC simd_uint(simd_double4  __x);
-static simd_uint8  SIMD_CFUNC simd_uint(simd_double8  __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_char2    __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_char3    __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_char4    __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_char8    __x);
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_char16   __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_short2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_short3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_short4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_short8   __x);
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_short16  __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_int2     __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_int3     __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_int4     __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_int8     __x);
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_int16    __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_float2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_float3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_float4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_float8   __x);
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_float16  __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_long2    __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_long3    __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_long4    __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_long8    __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_double2  __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_double3  __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_double4  __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_double8  __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_uchar2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_uchar3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_uchar4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_uchar8   __x);
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_uchar16  __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_ushort2  __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_ushort3  __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_ushort4  __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_ushort8  __x);
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_ushort16 __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_uint2    __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_uint3    __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_uint4    __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_uint8    __x);
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_uint16   __x);
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_ulong2   __x);
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_ulong3   __x);
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_ulong4   __x);
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_ulong8   __x);
-#define vector_uint simd_uint
-#define vector_uint_sat simd_uint_sat
-
-static simd_float2  SIMD_CFUNC simd_float(simd_char2    __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_char3    __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_char4    __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_char8    __x);
-static simd_float16 SIMD_CFUNC simd_float(simd_char16   __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_uchar2   __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_uchar3   __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_uchar4   __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_uchar8   __x);
-static simd_float16 SIMD_CFUNC simd_float(simd_uchar16  __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_short2   __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_short3   __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_short4   __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_short8   __x);
-static simd_float16 SIMD_CFUNC simd_float(simd_short16  __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_ushort2  __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_ushort3  __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_ushort4  __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_ushort8  __x);
-static simd_float16 SIMD_CFUNC simd_float(simd_ushort16 __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_int2     __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_int3     __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_int4     __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_int8     __x);
-static simd_float16 SIMD_CFUNC simd_float(simd_int16    __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_uint2    __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_uint3    __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_uint4    __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_uint8    __x);
-static simd_float16 SIMD_CFUNC simd_float(simd_uint16   __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_float2   __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_float3   __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_float4   __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_float8   __x);
-static simd_float16 SIMD_CFUNC simd_float(simd_float16  __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_long2    __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_long3    __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_long4    __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_long8    __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_ulong2   __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_ulong3   __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_ulong4   __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_ulong8   __x);
-static simd_float2  SIMD_CFUNC simd_float(simd_double2  __x);
-static simd_float3  SIMD_CFUNC simd_float(simd_double3  __x);
-static simd_float4  SIMD_CFUNC simd_float(simd_double4  __x);
-static simd_float8  SIMD_CFUNC simd_float(simd_double8  __x);
-#define vector_float simd_float
-
-static simd_long2  SIMD_CFUNC simd_long(simd_char2    __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_char3    __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_char4    __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_char8    __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_uchar2   __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_uchar3   __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_uchar4   __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_uchar8   __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_short2   __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_short3   __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_short4   __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_short8   __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_ushort2  __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_ushort3  __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_ushort4  __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_ushort8  __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_int2     __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_int3     __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_int4     __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_int8     __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_uint2    __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_uint3    __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_uint4    __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_uint8    __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_float2   __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_float3   __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_float4   __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_float8   __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_long2    __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_long3    __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_long4    __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_long8    __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_ulong2   __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_ulong3   __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_ulong4   __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_ulong8   __x);
-static simd_long2  SIMD_CFUNC simd_long(simd_double2  __x);
-static simd_long3  SIMD_CFUNC simd_long(simd_double3  __x);
-static simd_long4  SIMD_CFUNC simd_long(simd_double4  __x);
-static simd_long8  SIMD_CFUNC simd_long(simd_double8  __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_char2    __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_char3    __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_char4    __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_char8    __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_short2   __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_short3   __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_short4   __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_short8   __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_int2     __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_int3     __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_int4     __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_int8     __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_float2   __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_float3   __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_float4   __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_float8   __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_long2    __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_long3    __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_long4    __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_long8    __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_double2  __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_double3  __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_double4  __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_double8  __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_uchar2   __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_uchar3   __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_uchar4   __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_uchar8   __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_ushort2  __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_ushort3  __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_ushort4  __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_ushort8  __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_uint2    __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_uint3    __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_uint4    __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_uint8    __x);
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_ulong2   __x);
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_ulong3   __x);
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_ulong4   __x);
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_ulong8   __x);
-#define vector_long simd_long
-#define vector_long_sat simd_long_sat
-
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_char2    __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_char3    __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_char4    __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_char8    __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_uchar2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_uchar3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_uchar4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_uchar8   __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_short2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_short3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_short4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_short8   __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_ushort2  __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_ushort3  __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_ushort4  __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_ushort8  __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_int2     __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_int3     __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_int4     __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_int8     __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_uint2    __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_uint3    __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_uint4    __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_uint8    __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_float2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_float3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_float4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_float8   __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_long2    __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_long3    __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_long4    __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_long8    __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_ulong2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_ulong3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_ulong4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_ulong8   __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_double2  __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_double3  __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_double4  __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_double8  __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_char2    __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_char3    __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_char4    __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_char8    __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_short2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_short3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_short4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_short8   __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_int2     __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_int3     __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_int4     __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_int8     __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_float2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_float3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_float4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_float8   __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_long2    __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_long3    __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_long4    __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_long8    __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_double2  __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_double3  __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_double4  __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_double8  __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_uchar2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_uchar3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_uchar4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_uchar8   __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_ushort2  __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_ushort3  __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_ushort4  __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_ushort8  __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_uint2    __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_uint3    __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_uint4    __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_uint8    __x);
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_ulong2   __x);
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_ulong3   __x);
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_ulong4   __x);
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_ulong8   __x);
-#define vector_ulong simd_ulong
-#define vector_ulong_sat simd_ulong_sat
-
-static simd_double2  SIMD_CFUNC simd_double(simd_char2    __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_char3    __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_char4    __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_char8    __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_uchar2   __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_uchar3   __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_uchar4   __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_uchar8   __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_short2   __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_short3   __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_short4   __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_short8   __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_ushort2  __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_ushort3  __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_ushort4  __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_ushort8  __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_int2     __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_int3     __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_int4     __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_int8     __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_uint2    __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_uint3    __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_uint4    __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_uint8    __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_float2   __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_float3   __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_float4   __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_float8   __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_long2    __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_long3    __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_long4    __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_long8    __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_ulong2   __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_ulong3   __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_ulong4   __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_ulong8   __x);
-static simd_double2  SIMD_CFUNC simd_double(simd_double2  __x);
-static simd_double3  SIMD_CFUNC simd_double(simd_double3  __x);
-static simd_double4  SIMD_CFUNC simd_double(simd_double4  __x);
-static simd_double8  SIMD_CFUNC simd_double(simd_double8  __x);
-#define vector_double simd_double
-
-static simd_char2   SIMD_CFUNC vector2(char           __x, char           __y) { return (  simd_char2){__x, __y}; }
-static simd_uchar2  SIMD_CFUNC vector2(unsigned char  __x, unsigned char  __y) { return ( simd_uchar2){__x, __y}; }
-static simd_short2  SIMD_CFUNC vector2(short          __x, short          __y) { return ( simd_short2){__x, __y}; }
-static simd_ushort2 SIMD_CFUNC vector2(unsigned short __x, unsigned short __y) { return (simd_ushort2){__x, __y}; }
-static simd_int2    SIMD_CFUNC vector2(int            __x, int            __y) { return (   simd_int2){__x, __y}; }
-static simd_uint2   SIMD_CFUNC vector2(unsigned int   __x, unsigned int   __y) { return (  simd_uint2){__x, __y}; }
-static simd_float2  SIMD_CFUNC vector2(float          __x, float          __y) { return ( simd_float2){__x, __y}; }
-static simd_long2   SIMD_CFUNC vector2(simd_long1   __x, simd_long1   __y) { return (  simd_long2){__x, __y}; }
-static simd_ulong2  SIMD_CFUNC vector2(simd_ulong1  __x, simd_ulong1  __y) { return ( simd_ulong2){__x, __y}; }
-static simd_double2 SIMD_CFUNC vector2(double         __x, double         __y) { return (simd_double2){__x, __y}; }
-
-static simd_char3   SIMD_CFUNC vector3(char           __x, char           __y, char           __z) { return (  simd_char3){__x, __y, __z}; }
-static simd_uchar3  SIMD_CFUNC vector3(unsigned char  __x, unsigned char  __y, unsigned char  __z) { return ( simd_uchar3){__x, __y, __z}; }
-static simd_short3  SIMD_CFUNC vector3(short          __x, short          __y, short          __z) { return ( simd_short3){__x, __y, __z}; }
-static simd_ushort3 SIMD_CFUNC vector3(unsigned short __x, unsigned short __y, unsigned short __z) { return (simd_ushort3){__x, __y, __z}; }
-static simd_int3    SIMD_CFUNC vector3(int            __x, int            __y, int            __z) { return (   simd_int3){__x, __y, __z}; }
-static simd_uint3   SIMD_CFUNC vector3(unsigned int   __x, unsigned int   __y, unsigned int   __z) { return (  simd_uint3){__x, __y, __z}; }
-static simd_float3  SIMD_CFUNC vector3(float          __x, float          __y, float          __z) { return ( simd_float3){__x, __y, __z}; }
-static simd_long3   SIMD_CFUNC vector3(simd_long1   __x, simd_long1   __y, simd_long1   __z) { return (  simd_long3){__x, __y, __z}; }
-static simd_ulong3  SIMD_CFUNC vector3(simd_ulong1  __x, simd_ulong1  __y, simd_ulong1  __z) { return ( simd_ulong3){__x, __y, __z}; }
-static simd_double3 SIMD_CFUNC vector3(double         __x, double         __y, double         __z) { return (simd_double3){__x, __y, __z}; }
-
-static simd_char3   SIMD_CFUNC vector3(simd_char2   __xy, char           __z) { simd_char3   __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_uchar3  SIMD_CFUNC vector3(simd_uchar2  __xy, unsigned char  __z) { simd_uchar3  __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_short3  SIMD_CFUNC vector3(simd_short2  __xy, short          __z) { simd_short3  __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_ushort3 SIMD_CFUNC vector3(simd_ushort2 __xy, unsigned short __z) { simd_ushort3 __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_int3    SIMD_CFUNC vector3(simd_int2    __xy, int            __z) { simd_int3    __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_uint3   SIMD_CFUNC vector3(simd_uint2   __xy, unsigned int   __z) { simd_uint3   __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_float3  SIMD_CFUNC vector3(simd_float2  __xy, float          __z) { simd_float3  __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_long3   SIMD_CFUNC vector3(simd_long2   __xy, simd_long1   __z) { simd_long3   __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_ulong3  SIMD_CFUNC vector3(simd_ulong2  __xy, simd_ulong1  __z) { simd_ulong3  __r; __r.xy = __xy; __r.z = __z; return __r; }
-static simd_double3 SIMD_CFUNC vector3(simd_double2 __xy, double         __z) { simd_double3 __r; __r.xy = __xy; __r.z = __z; return __r; }
-
-static simd_char4   SIMD_CFUNC vector4(char           __x, char           __y, char           __z, char           __w) { return (  simd_char4){__x, __y, __z, __w}; }
-static simd_uchar4  SIMD_CFUNC vector4(unsigned char  __x, unsigned char  __y, unsigned char  __z, unsigned char  __w) { return ( simd_uchar4){__x, __y, __z, __w}; }
-static simd_short4  SIMD_CFUNC vector4(short          __x, short          __y, short          __z, short          __w) { return ( simd_short4){__x, __y, __z, __w}; }
-static simd_ushort4 SIMD_CFUNC vector4(unsigned short __x, unsigned short __y, unsigned short __z, unsigned short __w) { return (simd_ushort4){__x, __y, __z, __w}; }
-static simd_int4    SIMD_CFUNC vector4(int            __x, int            __y, int            __z, int            __w) { return (   simd_int4){__x, __y, __z, __w}; }
-static simd_uint4   SIMD_CFUNC vector4(unsigned int   __x, unsigned int   __y, unsigned int   __z, unsigned int   __w) { return (  simd_uint4){__x, __y, __z, __w}; }
-static simd_float4  SIMD_CFUNC vector4(float          __x, float          __y, float          __z, float          __w) { return ( simd_float4){__x, __y, __z, __w}; }
-static simd_long4   SIMD_CFUNC vector4(simd_long1   __x, simd_long1   __y, simd_long1   __z, simd_long1   __w) { return (  simd_long4){__x, __y, __z, __w}; }
-static simd_ulong4  SIMD_CFUNC vector4(simd_ulong1  __x, simd_ulong1  __y, simd_ulong1  __z, simd_ulong1  __w) { return ( simd_ulong4){__x, __y, __z, __w}; }
-static simd_double4 SIMD_CFUNC vector4(double         __x, double         __y, double         __z, double         __w) { return (simd_double4){__x, __y, __z, __w}; }
-
-static simd_char4   SIMD_CFUNC vector4(simd_char2   __xy, simd_char2   __zw) { simd_char4   __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_uchar4  SIMD_CFUNC vector4(simd_uchar2  __xy, simd_uchar2  __zw) { simd_uchar4  __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_short4  SIMD_CFUNC vector4(simd_short2  __xy, simd_short2  __zw) { simd_short4  __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_ushort4 SIMD_CFUNC vector4(simd_ushort2 __xy, simd_ushort2 __zw) { simd_ushort4 __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_int4    SIMD_CFUNC vector4(simd_int2    __xy, simd_int2    __zw) { simd_int4    __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_uint4   SIMD_CFUNC vector4(simd_uint2   __xy, simd_uint2   __zw) { simd_uint4   __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_float4  SIMD_CFUNC vector4(simd_float2  __xy, simd_float2  __zw) { simd_float4  __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_long4   SIMD_CFUNC vector4(simd_long2   __xy, simd_long2   __zw) { simd_long4   __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_ulong4  SIMD_CFUNC vector4(simd_ulong2  __xy, simd_ulong2  __zw) { simd_ulong4  __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-static simd_double4 SIMD_CFUNC vector4(simd_double2 __xy, simd_double2 __zw) { simd_double4 __r; __r.xy = __xy; __r.zw = __zw; return __r; }
-
-static simd_char4   SIMD_CFUNC vector4(simd_char3   __xyz, char           __w) { simd_char4   __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_uchar4  SIMD_CFUNC vector4(simd_uchar3  __xyz, unsigned char  __w) { simd_uchar4  __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_short4  SIMD_CFUNC vector4(simd_short3  __xyz, short          __w) { simd_short4  __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_ushort4 SIMD_CFUNC vector4(simd_ushort3 __xyz, unsigned short __w) { simd_ushort4 __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_int4    SIMD_CFUNC vector4(simd_int3    __xyz, int            __w) { simd_int4    __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_uint4   SIMD_CFUNC vector4(simd_uint3   __xyz, unsigned int   __w) { simd_uint4   __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_float4  SIMD_CFUNC vector4(simd_float3  __xyz, float          __w) { simd_float4  __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_long4   SIMD_CFUNC vector4(simd_long3   __xyz, simd_long1   __w) { simd_long4   __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_ulong4  SIMD_CFUNC vector4(simd_ulong3  __xyz, simd_ulong1  __w) { simd_ulong4  __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-static simd_double4 SIMD_CFUNC vector4(simd_double3 __xyz, double         __w) { simd_double4 __r; __r.xyz = __xyz; __r.w = __w; return __r; }
-
-static simd_char8   SIMD_CFUNC vector8(simd_char4   __lo, simd_char4   __hi) { simd_char8   __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_uchar8  SIMD_CFUNC vector8(simd_uchar4  __lo, simd_uchar4  __hi) { simd_uchar8  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_short8  SIMD_CFUNC vector8(simd_short4  __lo, simd_short4  __hi) { simd_short8  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_ushort8 SIMD_CFUNC vector8(simd_ushort4 __lo, simd_ushort4 __hi) { simd_ushort8 __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_int8    SIMD_CFUNC vector8(simd_int4    __lo, simd_int4    __hi) { simd_int8    __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_uint8   SIMD_CFUNC vector8(simd_uint4   __lo, simd_uint4   __hi) { simd_uint8   __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_float8  SIMD_CFUNC vector8(simd_float4  __lo, simd_float4  __hi) { simd_float8  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_long8   SIMD_CFUNC vector8(simd_long4   __lo, simd_long4   __hi) { simd_long8   __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_ulong8  SIMD_CFUNC vector8(simd_ulong4  __lo, simd_ulong4  __hi) { simd_ulong8  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_double8 SIMD_CFUNC vector8(simd_double4 __lo, simd_double4 __hi) { simd_double8 __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-
-static simd_char16   SIMD_CFUNC vector16(simd_char8   __lo, simd_char8   __hi) { simd_char16   __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_uchar16  SIMD_CFUNC vector16(simd_uchar8  __lo, simd_uchar8  __hi) { simd_uchar16  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_short16  SIMD_CFUNC vector16(simd_short8  __lo, simd_short8  __hi) { simd_short16  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_ushort16 SIMD_CFUNC vector16(simd_ushort8 __lo, simd_ushort8 __hi) { simd_ushort16 __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_int16    SIMD_CFUNC vector16(simd_int8    __lo, simd_int8    __hi) { simd_int16    __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_uint16   SIMD_CFUNC vector16(simd_uint8   __lo, simd_uint8   __hi) { simd_uint16   __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_float16  SIMD_CFUNC vector16(simd_float8  __lo, simd_float8  __hi) { simd_float16  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-
-static simd_char32   SIMD_CFUNC vector32(simd_char16   __lo, simd_char16   __hi) { simd_char32   __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_uchar32  SIMD_CFUNC vector32(simd_uchar16  __lo, simd_uchar16  __hi) { simd_uchar32  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_short32  SIMD_CFUNC vector32(simd_short16  __lo, simd_short16  __hi) { simd_short32  __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-static simd_ushort32 SIMD_CFUNC vector32(simd_ushort16 __lo, simd_ushort16 __hi) { simd_ushort32 __r; __r.lo = __lo; __r.hi = __hi; return __r; }
-
-#pragma mark - Implementation
-
-static simd_char2  SIMD_CFUNC simd_char(simd_char2    __x) { return __x; }
-static simd_char3  SIMD_CFUNC simd_char(simd_char3    __x) { return __x; }
-static simd_char4  SIMD_CFUNC simd_char(simd_char4    __x) { return __x; }
-static simd_char8  SIMD_CFUNC simd_char(simd_char8    __x) { return __x; }
-static simd_char16 SIMD_CFUNC simd_char(simd_char16   __x) { return __x; }
-static simd_char32 SIMD_CFUNC simd_char(simd_char32   __x) { return __x; }
-static simd_char2  SIMD_CFUNC simd_char(simd_uchar2   __x) { return (simd_char2)__x; }
-static simd_char3  SIMD_CFUNC simd_char(simd_uchar3   __x) { return (simd_char3)__x; }
-static simd_char4  SIMD_CFUNC simd_char(simd_uchar4   __x) { return (simd_char4)__x; }
-static simd_char8  SIMD_CFUNC simd_char(simd_uchar8   __x) { return (simd_char8)__x; }
-static simd_char16 SIMD_CFUNC simd_char(simd_uchar16  __x) { return (simd_char16)__x; }
-static simd_char32 SIMD_CFUNC simd_char(simd_uchar32  __x) { return (simd_char32)__x; }
-static simd_char2  SIMD_CFUNC simd_char(simd_short2   __x) { return __builtin_convertvector(__x & 0xff, simd_char2); }
-static simd_char3  SIMD_CFUNC simd_char(simd_short3   __x) { return __builtin_convertvector(__x & 0xff, simd_char3); }
-static simd_char4  SIMD_CFUNC simd_char(simd_short4   __x) { return __builtin_convertvector(__x & 0xff, simd_char4); }
-static simd_char8  SIMD_CFUNC simd_char(simd_short8   __x) { return __builtin_convertvector(__x & 0xff, simd_char8); }
-static simd_char16 SIMD_CFUNC simd_char(simd_short16  __x) { return __builtin_convertvector(__x & 0xff, simd_char16); }
-static simd_char32 SIMD_CFUNC simd_char(simd_short32  __x) { return __builtin_convertvector(__x & 0xff, simd_char32); }
-static simd_char2  SIMD_CFUNC simd_char(simd_ushort2  __x) { return simd_char(simd_short(__x)); }
-static simd_char3  SIMD_CFUNC simd_char(simd_ushort3  __x) { return simd_char(simd_short(__x)); }
-static simd_char4  SIMD_CFUNC simd_char(simd_ushort4  __x) { return simd_char(simd_short(__x)); }
-static simd_char8  SIMD_CFUNC simd_char(simd_ushort8  __x) { return simd_char(simd_short(__x)); }
-static simd_char16 SIMD_CFUNC simd_char(simd_ushort16 __x) { return simd_char(simd_short(__x)); }
-static simd_char32 SIMD_CFUNC simd_char(simd_ushort32 __x) { return simd_char(simd_short(__x)); }
-static simd_char2  SIMD_CFUNC simd_char(simd_int2     __x) { return simd_char(simd_short(__x)); }
-static simd_char3  SIMD_CFUNC simd_char(simd_int3     __x) { return simd_char(simd_short(__x)); }
-static simd_char4  SIMD_CFUNC simd_char(simd_int4     __x) { return simd_char(simd_short(__x)); }
-static simd_char8  SIMD_CFUNC simd_char(simd_int8     __x) { return simd_char(simd_short(__x)); }
-static simd_char16 SIMD_CFUNC simd_char(simd_int16    __x) { return simd_char(simd_short(__x)); }
-static simd_char2  SIMD_CFUNC simd_char(simd_uint2    __x) { return simd_char(simd_short(__x)); }
-static simd_char3  SIMD_CFUNC simd_char(simd_uint3    __x) { return simd_char(simd_short(__x)); }
-static simd_char4  SIMD_CFUNC simd_char(simd_uint4    __x) { return simd_char(simd_short(__x)); }
-static simd_char8  SIMD_CFUNC simd_char(simd_uint8    __x) { return simd_char(simd_short(__x)); }
-static simd_char16 SIMD_CFUNC simd_char(simd_uint16   __x) { return simd_char(simd_short(__x)); }
-static simd_char2  SIMD_CFUNC simd_char(simd_float2   __x) { return simd_char(simd_short(__x)); }
-static simd_char3  SIMD_CFUNC simd_char(simd_float3   __x) { return simd_char(simd_short(__x)); }
-static simd_char4  SIMD_CFUNC simd_char(simd_float4   __x) { return simd_char(simd_short(__x)); }
-static simd_char8  SIMD_CFUNC simd_char(simd_float8   __x) { return simd_char(simd_short(__x)); }
-static simd_char16 SIMD_CFUNC simd_char(simd_float16  __x) { return simd_char(simd_short(__x)); }
-static simd_char2  SIMD_CFUNC simd_char(simd_long2    __x) { return simd_char(simd_short(__x)); }
-static simd_char3  SIMD_CFUNC simd_char(simd_long3    __x) { return simd_char(simd_short(__x)); }
-static simd_char4  SIMD_CFUNC simd_char(simd_long4    __x) { return simd_char(simd_short(__x)); }
-static simd_char8  SIMD_CFUNC simd_char(simd_long8    __x) { return simd_char(simd_short(__x)); }
-static simd_char2  SIMD_CFUNC simd_char(simd_ulong2   __x) { return simd_char(simd_short(__x)); }
-static simd_char3  SIMD_CFUNC simd_char(simd_ulong3   __x) { return simd_char(simd_short(__x)); }
-static simd_char4  SIMD_CFUNC simd_char(simd_ulong4   __x) { return simd_char(simd_short(__x)); }
-static simd_char8  SIMD_CFUNC simd_char(simd_ulong8   __x) { return simd_char(simd_short(__x)); }
-static simd_char2  SIMD_CFUNC simd_char(simd_double2  __x) { return simd_char(simd_short(__x)); }
-static simd_char3  SIMD_CFUNC simd_char(simd_double3  __x) { return simd_char(simd_short(__x)); }
-static simd_char4  SIMD_CFUNC simd_char(simd_double4  __x) { return simd_char(simd_short(__x)); }
-static simd_char8  SIMD_CFUNC simd_char(simd_double8  __x) { return simd_char(simd_short(__x)); }
-    
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_char2    __x) { return __x; }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_char3    __x) { return __x; }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_char4    __x) { return __x; }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_char8    __x) { return __x; }
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_char16   __x) { return __x; }
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_char32   __x) { return __x; }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_short2   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_short3   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_short4   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_short8   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_short16  __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_short32  __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_int2     __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_int3     __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_int4     __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_int8     __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_int16    __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_float2   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_float3   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_float4   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_float8   __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_float16  __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_long2    __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_long3    __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_long4    __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_long8    __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_double2  __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_double3  __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_double4  __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_double8  __x) { return simd_char(simd_clamp(__x,-0x80,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_uchar2   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_uchar3   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_uchar4   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_uchar8   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_uchar16  __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_uchar32  __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_ushort2  __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_ushort3  __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_ushort4  __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_ushort8  __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_ushort16 __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char32 SIMD_CFUNC simd_char_sat(simd_ushort32 __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_uint2    __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_uint3    __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_uint4    __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_uint8    __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char16 SIMD_CFUNC simd_char_sat(simd_uint16   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char2  SIMD_CFUNC simd_char_sat(simd_ulong2   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char3  SIMD_CFUNC simd_char_sat(simd_ulong3   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char4  SIMD_CFUNC simd_char_sat(simd_ulong4   __x) { return simd_char(simd_min(__x,0x7f)); }
-static simd_char8  SIMD_CFUNC simd_char_sat(simd_ulong8   __x) { return simd_char(simd_min(__x,0x7f)); }
-
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_char2    __x) { return (simd_uchar2)__x; }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_char3    __x) { return (simd_uchar3)__x; }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_char4    __x) { return (simd_uchar4)__x; }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_char8    __x) { return (simd_uchar8)__x; }
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_char16   __x) { return (simd_uchar16)__x; }
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_char32   __x) { return (simd_uchar32)__x; }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_uchar2   __x) { return __x; }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_uchar3   __x) { return __x; }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_uchar4   __x) { return __x; }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_uchar8   __x) { return __x; }
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_uchar16  __x) { return __x; }
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_uchar32  __x) { return __x; }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_short2   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_short3   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_short4   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_short8   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_short16  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_short32  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_ushort2  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_ushort3  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_ushort4  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_ushort8  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_ushort16 __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar32 SIMD_CFUNC simd_uchar(simd_ushort32 __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_int2     __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_int3     __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_int4     __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_int8     __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_int16    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_uint2    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_uint3    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_uint4    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_uint8    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_uint16   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_float2   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_float3   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_float4   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_float8   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar(simd_float16  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_long2    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_long3    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_long4    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_long8    __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_ulong2   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_ulong3   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_ulong4   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_ulong8   __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar(simd_double2  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar(simd_double3  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar(simd_double4  __x) { return simd_uchar(simd_char(__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar(simd_double8  __x) { return simd_uchar(simd_char(__x)); }
-    
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_char2    __x) { return simd_uchar(simd_max(0,__x)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_char3    __x) { return simd_uchar(simd_max(0,__x)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_char4    __x) { return simd_uchar(simd_max(0,__x)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_char8    __x) { return simd_uchar(simd_max(0,__x)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_char16   __x) { return simd_uchar(simd_max(0,__x)); }
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_char32   __x) { return simd_uchar(simd_max(0,__x)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_short2   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_short3   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_short4   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_short8   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_short16  __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_short32  __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_int2     __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_int3     __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_int4     __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_int8     __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_int16    __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_float2   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_float3   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_float4   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_float8   __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_float16  __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_long2    __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_long3    __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_long4    __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_long8    __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_double2  __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_double3  __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_double4  __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_double8  __x) { return simd_uchar(simd_clamp(__x,0,0xff)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_uchar2   __x) { return __x; }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_uchar3   __x) { return __x; }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_uchar4   __x) { return __x; }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_uchar8   __x) { return __x; }
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_uchar16  __x) { return __x; }
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_uchar32  __x) { return __x; }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_ushort2  __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_ushort3  __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_ushort4  __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_ushort8  __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_ushort16 __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar32 SIMD_CFUNC simd_uchar_sat(simd_ushort32 __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_uint2    __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_uint3    __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_uint4    __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_uint8    __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar16 SIMD_CFUNC simd_uchar_sat(simd_uint16   __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar2  SIMD_CFUNC simd_uchar_sat(simd_ulong2   __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar3  SIMD_CFUNC simd_uchar_sat(simd_ulong3   __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar4  SIMD_CFUNC simd_uchar_sat(simd_ulong4   __x) { return simd_uchar(simd_min(__x,0xff)); }
-static simd_uchar8  SIMD_CFUNC simd_uchar_sat(simd_ulong8   __x) { return simd_uchar(simd_min(__x,0xff)); }
-
-static simd_short2  SIMD_CFUNC simd_short(simd_char2    __x) { return __builtin_convertvector(__x, simd_short2); }
-static simd_short3  SIMD_CFUNC simd_short(simd_char3    __x) { return __builtin_convertvector(__x, simd_short3); }
-static simd_short4  SIMD_CFUNC simd_short(simd_char4    __x) { return __builtin_convertvector(__x, simd_short4); }
-static simd_short8  SIMD_CFUNC simd_short(simd_char8    __x) { return __builtin_convertvector(__x, simd_short8); }
-static simd_short16 SIMD_CFUNC simd_short(simd_char16   __x) { return __builtin_convertvector(__x, simd_short16); }
-static simd_short32 SIMD_CFUNC simd_short(simd_char32   __x) { return __builtin_convertvector(__x, simd_short32); }
-static simd_short2  SIMD_CFUNC simd_short(simd_uchar2   __x) { return __builtin_convertvector(__x, simd_short2); }
-static simd_short3  SIMD_CFUNC simd_short(simd_uchar3   __x) { return __builtin_convertvector(__x, simd_short3); }
-static simd_short4  SIMD_CFUNC simd_short(simd_uchar4   __x) { return __builtin_convertvector(__x, simd_short4); }
-static simd_short8  SIMD_CFUNC simd_short(simd_uchar8   __x) { return __builtin_convertvector(__x, simd_short8); }
-static simd_short16 SIMD_CFUNC simd_short(simd_uchar16  __x) { return __builtin_convertvector(__x, simd_short16); }
-static simd_short32 SIMD_CFUNC simd_short(simd_uchar32  __x) { return __builtin_convertvector(__x, simd_short32); }
-static simd_short2  SIMD_CFUNC simd_short(simd_short2   __x) { return __x; }
-static simd_short3  SIMD_CFUNC simd_short(simd_short3   __x) { return __x; }
-static simd_short4  SIMD_CFUNC simd_short(simd_short4   __x) { return __x; }
-static simd_short8  SIMD_CFUNC simd_short(simd_short8   __x) { return __x; }
-static simd_short16 SIMD_CFUNC simd_short(simd_short16  __x) { return __x; }
-static simd_short32 SIMD_CFUNC simd_short(simd_short32  __x) { return __x; }
-static simd_short2  SIMD_CFUNC simd_short(simd_ushort2  __x) { return (simd_short2)__x; }
-static simd_short3  SIMD_CFUNC simd_short(simd_ushort3  __x) { return (simd_short3)__x; }
-static simd_short4  SIMD_CFUNC simd_short(simd_ushort4  __x) { return (simd_short4)__x; }
-static simd_short8  SIMD_CFUNC simd_short(simd_ushort8  __x) { return (simd_short8)__x; }
-static simd_short16 SIMD_CFUNC simd_short(simd_ushort16 __x) { return (simd_short16)__x; }
-static simd_short32 SIMD_CFUNC simd_short(simd_ushort32 __x) { return (simd_short32)__x; }
-static simd_short2  SIMD_CFUNC simd_short(simd_int2     __x) { return __builtin_convertvector(__x & 0xffff, simd_short2); }
-static simd_short3  SIMD_CFUNC simd_short(simd_int3     __x) { return __builtin_convertvector(__x & 0xffff, simd_short3); }
-static simd_short4  SIMD_CFUNC simd_short(simd_int4     __x) { return __builtin_convertvector(__x & 0xffff, simd_short4); }
-static simd_short8  SIMD_CFUNC simd_short(simd_int8     __x) { return __builtin_convertvector(__x & 0xffff, simd_short8); }
-static simd_short16 SIMD_CFUNC simd_short(simd_int16    __x) { return __builtin_convertvector(__x & 0xffff, simd_short16); }
-static simd_short2  SIMD_CFUNC simd_short(simd_uint2    __x) { return simd_short(simd_int(__x)); }
-static simd_short3  SIMD_CFUNC simd_short(simd_uint3    __x) { return simd_short(simd_int(__x)); }
-static simd_short4  SIMD_CFUNC simd_short(simd_uint4    __x) { return simd_short(simd_int(__x)); }
-static simd_short8  SIMD_CFUNC simd_short(simd_uint8    __x) { return simd_short(simd_int(__x)); }
-static simd_short16 SIMD_CFUNC simd_short(simd_uint16   __x) { return simd_short(simd_int(__x)); }
-static simd_short2  SIMD_CFUNC simd_short(simd_float2   __x) { return simd_short(simd_int(__x)); }
-static simd_short3  SIMD_CFUNC simd_short(simd_float3   __x) { return simd_short(simd_int(__x)); }
-static simd_short4  SIMD_CFUNC simd_short(simd_float4   __x) { return simd_short(simd_int(__x)); }
-static simd_short8  SIMD_CFUNC simd_short(simd_float8   __x) { return simd_short(simd_int(__x)); }
-static simd_short16 SIMD_CFUNC simd_short(simd_float16  __x) { return simd_short(simd_int(__x)); }
-static simd_short2  SIMD_CFUNC simd_short(simd_long2    __x) { return simd_short(simd_int(__x)); }
-static simd_short3  SIMD_CFUNC simd_short(simd_long3    __x) { return simd_short(simd_int(__x)); }
-static simd_short4  SIMD_CFUNC simd_short(simd_long4    __x) { return simd_short(simd_int(__x)); }
-static simd_short8  SIMD_CFUNC simd_short(simd_long8    __x) { return simd_short(simd_int(__x)); }
-static simd_short2  SIMD_CFUNC simd_short(simd_ulong2   __x) { return simd_short(simd_int(__x)); }
-static simd_short3  SIMD_CFUNC simd_short(simd_ulong3   __x) { return simd_short(simd_int(__x)); }
-static simd_short4  SIMD_CFUNC simd_short(simd_ulong4   __x) { return simd_short(simd_int(__x)); }
-static simd_short8  SIMD_CFUNC simd_short(simd_ulong8   __x) { return simd_short(simd_int(__x)); }
-static simd_short2  SIMD_CFUNC simd_short(simd_double2  __x) { return simd_short(simd_int(__x)); }
-static simd_short3  SIMD_CFUNC simd_short(simd_double3  __x) { return simd_short(simd_int(__x)); }
-static simd_short4  SIMD_CFUNC simd_short(simd_double4  __x) { return simd_short(simd_int(__x)); }
-static simd_short8  SIMD_CFUNC simd_short(simd_double8  __x) { return simd_short(simd_int(__x)); }
-    
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_char2    __x) { return simd_short(__x); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_char3    __x) { return simd_short(__x); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_char4    __x) { return simd_short(__x); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_char8    __x) { return simd_short(__x); }
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_char16   __x) { return simd_short(__x); }
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_char32   __x) { return simd_short(__x); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_short2   __x) { return __x; }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_short3   __x) { return __x; }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_short4   __x) { return __x; }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_short8   __x) { return __x; }
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_short16  __x) { return __x; }
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_short32  __x) { return __x; }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_int2     __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_int3     __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_int4     __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_int8     __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_int16    __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_float2   __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_float3   __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_float4   __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_float8   __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_float16  __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_long2    __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_long3    __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_long4    __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_long8    __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_double2  __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_double3  __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_double4  __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_double8  __x) { return simd_short(simd_clamp(__x,-0x8000,0x7fff)); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_uchar2   __x) { return simd_short(__x); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_uchar3   __x) { return simd_short(__x); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_uchar4   __x) { return simd_short(__x); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_uchar8   __x) { return simd_short(__x); }
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_uchar16  __x) { return simd_short(__x); }
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_uchar32  __x) { return simd_short(__x); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_ushort2  __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_ushort3  __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_ushort4  __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_ushort8  __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_ushort16 __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short32 SIMD_CFUNC simd_short_sat(simd_ushort32 __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_uint2    __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_uint3    __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_uint4    __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_uint8    __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short16 SIMD_CFUNC simd_short_sat(simd_uint16   __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short2  SIMD_CFUNC simd_short_sat(simd_ulong2   __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short3  SIMD_CFUNC simd_short_sat(simd_ulong3   __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short4  SIMD_CFUNC simd_short_sat(simd_ulong4   __x) { return simd_short(simd_min(__x,0x7fff)); }
-static simd_short8  SIMD_CFUNC simd_short_sat(simd_ulong8   __x) { return simd_short(simd_min(__x,0x7fff)); }
-
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_char2    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_char3    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_char4    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_char8    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_char16   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_char32   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_uchar2   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_uchar3   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_uchar4   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_uchar8   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_uchar16  __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_uchar32  __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_short2   __x) { return (simd_ushort2)__x; }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_short3   __x) { return (simd_ushort3)__x; }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_short4   __x) { return (simd_ushort4)__x; }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_short8   __x) { return (simd_ushort8)__x; }
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_short16  __x) { return (simd_ushort16)__x; }
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_short32  __x) { return (simd_ushort32)__x; }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_ushort2  __x) { return __x; }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_ushort3  __x) { return __x; }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_ushort4  __x) { return __x; }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_ushort8  __x) { return __x; }
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_ushort16 __x) { return __x; }
-static simd_ushort32 SIMD_CFUNC simd_ushort(simd_ushort32 __x) { return __x; }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_int2     __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_int3     __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_int4     __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_int8     __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_int16    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_uint2    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_uint3    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_uint4    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_uint8    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_uint16   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_float2   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_float3   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_float4   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_float8   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort(simd_float16  __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_long2    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_long3    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_long4    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_long8    __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_ulong2   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_ulong3   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_ulong4   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_ulong8   __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort(simd_double2  __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort(simd_double3  __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort(simd_double4  __x) { return simd_ushort(simd_short(__x)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort(simd_double8  __x) { return simd_ushort(simd_short(__x)); }
-    
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_char2    __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_char3    __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_char4    __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_char8    __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_char16   __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_char32   __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_short2   __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_short3   __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_short4   __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_short8   __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_short16  __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_short32  __x) { return simd_ushort(simd_max(__x, 0)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_int2     __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_int3     __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_int4     __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_int8     __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_int16    __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_float2   __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_float3   __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_float4   __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_float8   __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_float16  __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_long2    __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_long3    __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_long4    __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_long8    __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_double2  __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_double3  __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_double4  __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_double8  __x) { return simd_ushort(simd_clamp(__x, 0, 0xffff)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_uchar2   __x) { return simd_ushort(__x); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_uchar3   __x) { return simd_ushort(__x); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_uchar4   __x) { return simd_ushort(__x); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_uchar8   __x) { return simd_ushort(__x); }
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_uchar16  __x) { return simd_ushort(__x); }
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_uchar32  __x) { return simd_ushort(__x); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_ushort2  __x) { return __x; }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_ushort3  __x) { return __x; }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_ushort4  __x) { return __x; }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_ushort8  __x) { return __x; }
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_ushort16 __x) { return __x; }
-static simd_ushort32 SIMD_CFUNC simd_ushort_sat(simd_ushort32 __x) { return __x; }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_uint2    __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_uint3    __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_uint4    __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_uint8    __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort16 SIMD_CFUNC simd_ushort_sat(simd_uint16   __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort2  SIMD_CFUNC simd_ushort_sat(simd_ulong2   __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort3  SIMD_CFUNC simd_ushort_sat(simd_ulong3   __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort4  SIMD_CFUNC simd_ushort_sat(simd_ulong4   __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-static simd_ushort8  SIMD_CFUNC simd_ushort_sat(simd_ulong8   __x) { return simd_ushort(simd_min(__x, 0xffff)); }
-
-static simd_int2  SIMD_CFUNC simd_int(simd_char2    __x) { return __builtin_convertvector(__x, simd_int2); }
-static simd_int3  SIMD_CFUNC simd_int(simd_char3    __x) { return __builtin_convertvector(__x, simd_int3); }
-static simd_int4  SIMD_CFUNC simd_int(simd_char4    __x) { return __builtin_convertvector(__x, simd_int4); }
-static simd_int8  SIMD_CFUNC simd_int(simd_char8    __x) { return __builtin_convertvector(__x, simd_int8); }
-static simd_int16 SIMD_CFUNC simd_int(simd_char16   __x) { return __builtin_convertvector(__x, simd_int16); }
-static simd_int2  SIMD_CFUNC simd_int(simd_uchar2   __x) { return __builtin_convertvector(__x, simd_int2); }
-static simd_int3  SIMD_CFUNC simd_int(simd_uchar3   __x) { return __builtin_convertvector(__x, simd_int3); }
-static simd_int4  SIMD_CFUNC simd_int(simd_uchar4   __x) { return __builtin_convertvector(__x, simd_int4); }
-static simd_int8  SIMD_CFUNC simd_int(simd_uchar8   __x) { return __builtin_convertvector(__x, simd_int8); }
-static simd_int16 SIMD_CFUNC simd_int(simd_uchar16  __x) { return __builtin_convertvector(__x, simd_int16); }
-static simd_int2  SIMD_CFUNC simd_int(simd_short2   __x) { return __builtin_convertvector(__x, simd_int2); }
-static simd_int3  SIMD_CFUNC simd_int(simd_short3   __x) { return __builtin_convertvector(__x, simd_int3); }
-static simd_int4  SIMD_CFUNC simd_int(simd_short4   __x) { return __builtin_convertvector(__x, simd_int4); }
-static simd_int8  SIMD_CFUNC simd_int(simd_short8   __x) { return __builtin_convertvector(__x, simd_int8); }
-static simd_int16 SIMD_CFUNC simd_int(simd_short16  __x) { return __builtin_convertvector(__x, simd_int16); }
-static simd_int2  SIMD_CFUNC simd_int(simd_ushort2  __x) { return __builtin_convertvector(__x, simd_int2); }
-static simd_int3  SIMD_CFUNC simd_int(simd_ushort3  __x) { return __builtin_convertvector(__x, simd_int3); }
-static simd_int4  SIMD_CFUNC simd_int(simd_ushort4  __x) { return __builtin_convertvector(__x, simd_int4); }
-static simd_int8  SIMD_CFUNC simd_int(simd_ushort8  __x) { return __builtin_convertvector(__x, simd_int8); }
-static simd_int16 SIMD_CFUNC simd_int(simd_ushort16 __x) { return __builtin_convertvector(__x, simd_int16); }
-static simd_int2  SIMD_CFUNC simd_int(simd_int2     __x) { return __x; }
-static simd_int3  SIMD_CFUNC simd_int(simd_int3     __x) { return __x; }
-static simd_int4  SIMD_CFUNC simd_int(simd_int4     __x) { return __x; }
-static simd_int8  SIMD_CFUNC simd_int(simd_int8     __x) { return __x; }
-static simd_int16 SIMD_CFUNC simd_int(simd_int16    __x) { return __x; }
-static simd_int2  SIMD_CFUNC simd_int(simd_uint2    __x) { return (simd_int2)__x; }
-static simd_int3  SIMD_CFUNC simd_int(simd_uint3    __x) { return (simd_int3)__x; }
-static simd_int4  SIMD_CFUNC simd_int(simd_uint4    __x) { return (simd_int4)__x; }
-static simd_int8  SIMD_CFUNC simd_int(simd_uint8    __x) { return (simd_int8)__x; }
-static simd_int16 SIMD_CFUNC simd_int(simd_uint16   __x) { return (simd_int16)__x; }
-static simd_int2  SIMD_CFUNC simd_int(simd_float2   __x) { return __builtin_convertvector(__x, simd_int2); }
-static simd_int3  SIMD_CFUNC simd_int(simd_float3   __x) { return __builtin_convertvector(__x, simd_int3); }
-static simd_int4  SIMD_CFUNC simd_int(simd_float4   __x) { return __builtin_convertvector(__x, simd_int4); }
-static simd_int8  SIMD_CFUNC simd_int(simd_float8   __x) { return __builtin_convertvector(__x, simd_int8); }
-static simd_int16 SIMD_CFUNC simd_int(simd_float16  __x) { return __builtin_convertvector(__x, simd_int16); }
-static simd_int2  SIMD_CFUNC simd_int(simd_long2    __x) { return __builtin_convertvector(__x & 0xffffffff, simd_int2); }
-static simd_int3  SIMD_CFUNC simd_int(simd_long3    __x) { return __builtin_convertvector(__x & 0xffffffff, simd_int3); }
-static simd_int4  SIMD_CFUNC simd_int(simd_long4    __x) { return __builtin_convertvector(__x & 0xffffffff, simd_int4); }
-static simd_int8  SIMD_CFUNC simd_int(simd_long8    __x) { return __builtin_convertvector(__x & 0xffffffff, simd_int8); }
-static simd_int2  SIMD_CFUNC simd_int(simd_ulong2   __x) { return simd_int(simd_long(__x)); }
-static simd_int3  SIMD_CFUNC simd_int(simd_ulong3   __x) { return simd_int(simd_long(__x)); }
-static simd_int4  SIMD_CFUNC simd_int(simd_ulong4   __x) { return simd_int(simd_long(__x)); }
-static simd_int8  SIMD_CFUNC simd_int(simd_ulong8   __x) { return simd_int(simd_long(__x)); }
-static simd_int2  SIMD_CFUNC simd_int(simd_double2  __x) { return __builtin_convertvector(__x, simd_int2); }
-static simd_int3  SIMD_CFUNC simd_int(simd_double3  __x) { return __builtin_convertvector(__x, simd_int3); }
-static simd_int4  SIMD_CFUNC simd_int(simd_double4  __x) { return __builtin_convertvector(__x, simd_int4); }
-static simd_int8  SIMD_CFUNC simd_int(simd_double8  __x) { return __builtin_convertvector(__x, simd_int8); }
-    
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_char2    __x) { return simd_int(__x); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_char3    __x) { return simd_int(__x); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_char4    __x) { return simd_int(__x); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_char8    __x) { return simd_int(__x); }
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_char16   __x) { return simd_int(__x); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_short2   __x) { return simd_int(__x); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_short3   __x) { return simd_int(__x); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_short4   __x) { return simd_int(__x); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_short8   __x) { return simd_int(__x); }
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_short16  __x) { return simd_int(__x); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_int2     __x) { return __x; }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_int3     __x) { return __x; }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_int4     __x) { return __x; }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_int8     __x) { return __x; }
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_int16    __x) { return __x; }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_float2   __x) { return simd_bitselect(simd_int(simd_max(__x,-0x1.0p31f)), 0x7fffffff, __x >= 0x1.0p31f); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_float3   __x) { return simd_bitselect(simd_int(simd_max(__x,-0x1.0p31f)), 0x7fffffff, __x >= 0x1.0p31f); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_float4   __x) { return simd_bitselect(simd_int(simd_max(__x,-0x1.0p31f)), 0x7fffffff, __x >= 0x1.0p31f); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_float8   __x) { return simd_bitselect(simd_int(simd_max(__x,-0x1.0p31f)), 0x7fffffff, __x >= 0x1.0p31f); }
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_float16  __x) { return simd_bitselect(simd_int(simd_max(__x,-0x1.0p31f)), 0x7fffffff, __x >= 0x1.0p31f); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_long2    __x) { return simd_int(simd_clamp(__x,-0x80000000LL,0x7fffffffLL)); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_long3    __x) { return simd_int(simd_clamp(__x,-0x80000000LL,0x7fffffffLL)); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_long4    __x) { return simd_int(simd_clamp(__x,-0x80000000LL,0x7fffffffLL)); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_long8    __x) { return simd_int(simd_clamp(__x,-0x80000000LL,0x7fffffffLL)); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_double2  __x) { return simd_int(simd_clamp(__x,-0x1.0p31,0x1.fffffffcp30)); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_double3  __x) { return simd_int(simd_clamp(__x,-0x1.0p31,0x1.fffffffcp30)); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_double4  __x) { return simd_int(simd_clamp(__x,-0x1.0p31,0x1.fffffffcp30)); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_double8  __x) { return simd_int(simd_clamp(__x,-0x1.0p31,0x1.fffffffcp30)); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_uchar2   __x) { return simd_int(__x); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_uchar3   __x) { return simd_int(__x); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_uchar4   __x) { return simd_int(__x); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_uchar8   __x) { return simd_int(__x); }
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_uchar16  __x) { return simd_int(__x); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_ushort2  __x) { return simd_int(__x); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_ushort3  __x) { return simd_int(__x); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_ushort4  __x) { return simd_int(__x); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_ushort8  __x) { return simd_int(__x); }
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_ushort16 __x) { return simd_int(__x); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_uint2    __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_uint3    __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_uint4    __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_uint8    __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int16 SIMD_CFUNC simd_int_sat(simd_uint16   __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int2  SIMD_CFUNC simd_int_sat(simd_ulong2   __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int3  SIMD_CFUNC simd_int_sat(simd_ulong3   __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int4  SIMD_CFUNC simd_int_sat(simd_ulong4   __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-static simd_int8  SIMD_CFUNC simd_int_sat(simd_ulong8   __x) { return simd_int(simd_min(__x,0x7fffffff)); }
-
-static simd_uint2  SIMD_CFUNC simd_uint(simd_char2    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_char3    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_char4    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_char8    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint16 SIMD_CFUNC simd_uint(simd_char16   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_uchar2   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_uchar3   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_uchar4   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_uchar8   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint16 SIMD_CFUNC simd_uint(simd_uchar16  __x) { return simd_uint(simd_int(__x)); }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_short2   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_short3   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_short4   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_short8   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint16 SIMD_CFUNC simd_uint(simd_short16  __x) { return simd_uint(simd_int(__x)); }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_ushort2  __x) { return simd_uint(simd_int(__x)); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_ushort3  __x) { return simd_uint(simd_int(__x)); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_ushort4  __x) { return simd_uint(simd_int(__x)); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_ushort8  __x) { return simd_uint(simd_int(__x)); }
-static simd_uint16 SIMD_CFUNC simd_uint(simd_ushort16 __x) { return simd_uint(simd_int(__x)); }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_int2     __x) { return (simd_uint2)__x; }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_int3     __x) { return (simd_uint3)__x; }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_int4     __x) { return (simd_uint4)__x; }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_int8     __x) { return (simd_uint8)__x; }
-static simd_uint16 SIMD_CFUNC simd_uint(simd_int16    __x) { return (simd_uint16)__x; }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_uint2    __x) { return __x; }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_uint3    __x) { return __x; }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_uint4    __x) { return __x; }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_uint8    __x) { return __x; }
-static simd_uint16 SIMD_CFUNC simd_uint(simd_uint16   __x) { return __x; }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_float2   __x) { simd_int2  __big = __x > 0x1.0p31f; return simd_uint(simd_int(__x - simd_bitselect((simd_float2)0,0x1.0p31f,__big))) + simd_bitselect((simd_uint2)0,0x80000000,__big); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_float3   __x) { simd_int3  __big = __x > 0x1.0p31f; return simd_uint(simd_int(__x - simd_bitselect((simd_float3)0,0x1.0p31f,__big))) + simd_bitselect((simd_uint3)0,0x80000000,__big); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_float4   __x) { simd_int4  __big = __x > 0x1.0p31f; return simd_uint(simd_int(__x - simd_bitselect((simd_float4)0,0x1.0p31f,__big))) + simd_bitselect((simd_uint4)0,0x80000000,__big); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_float8   __x) { simd_int8  __big = __x > 0x1.0p31f; return simd_uint(simd_int(__x - simd_bitselect((simd_float8)0,0x1.0p31f,__big))) + simd_bitselect((simd_uint8)0,0x80000000,__big); }
-static simd_uint16 SIMD_CFUNC simd_uint(simd_float16  __x) { simd_int16 __big = __x > 0x1.0p31f; return simd_uint(simd_int(__x - simd_bitselect((simd_float16)0,0x1.0p31f,__big))) + simd_bitselect((simd_uint16)0,0x80000000,__big); }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_long2    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_long3    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_long4    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_long8    __x) { return simd_uint(simd_int(__x)); }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_ulong2   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_ulong3   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_ulong4   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_ulong8   __x) { return simd_uint(simd_int(__x)); }
-static simd_uint2  SIMD_CFUNC simd_uint(simd_double2  __x) { simd_long2 __big = __x > 0x1.fffffffcp30; return simd_uint(simd_int(__x - simd_bitselect((simd_double2)0,0x1.0p31,__big))) + simd_bitselect((simd_uint2)0,0x80000000,simd_int(__big)); }
-static simd_uint3  SIMD_CFUNC simd_uint(simd_double3  __x) { simd_long3 __big = __x > 0x1.fffffffcp30; return simd_uint(simd_int(__x - simd_bitselect((simd_double3)0,0x1.0p31,__big))) + simd_bitselect((simd_uint3)0,0x80000000,simd_int(__big)); }
-static simd_uint4  SIMD_CFUNC simd_uint(simd_double4  __x) { simd_long4 __big = __x > 0x1.fffffffcp30; return simd_uint(simd_int(__x - simd_bitselect((simd_double4)0,0x1.0p31,__big))) + simd_bitselect((simd_uint4)0,0x80000000,simd_int(__big)); }
-static simd_uint8  SIMD_CFUNC simd_uint(simd_double8  __x) { simd_long8 __big = __x > 0x1.fffffffcp30; return simd_uint(simd_int(__x - simd_bitselect((simd_double8)0,0x1.0p31,__big))) + simd_bitselect((simd_uint8)0,0x80000000,simd_int(__big)); }
-    
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_char2    __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_char3    __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_char4    __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_char8    __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_char16   __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_short2   __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_short3   __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_short4   __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_short8   __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_short16  __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_int2     __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_int3     __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_int4     __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_int8     __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_int16    __x) { return simd_uint(simd_max(__x,0)); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_float2   __x) { return simd_bitselect(simd_uint(simd_max(__x,0)), 0xffffffff, __x >= 0x1.0p32f); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_float3   __x) { return simd_bitselect(simd_uint(simd_max(__x,0)), 0xffffffff, __x >= 0x1.0p32f); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_float4   __x) { return simd_bitselect(simd_uint(simd_max(__x,0)), 0xffffffff, __x >= 0x1.0p32f); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_float8   __x) { return simd_bitselect(simd_uint(simd_max(__x,0)), 0xffffffff, __x >= 0x1.0p32f); }
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_float16  __x) { return simd_bitselect(simd_uint(simd_max(__x,0)), 0xffffffff, __x >= 0x1.0p32f); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_long2    __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_long3    __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_long4    __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_long8    __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_double2  __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_double3  __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_double4  __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_double8  __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_uchar2   __x) { return simd_uint(__x); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_uchar3   __x) { return simd_uint(__x); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_uchar4   __x) { return simd_uint(__x); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_uchar8   __x) { return simd_uint(__x); }
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_uchar16  __x) { return simd_uint(__x); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_ushort2  __x) { return simd_uint(__x); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_ushort3  __x) { return simd_uint(__x); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_ushort4  __x) { return simd_uint(__x); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_ushort8  __x) { return simd_uint(__x); }
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_ushort16 __x) { return simd_uint(__x); }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_uint2    __x) { return __x; }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_uint3    __x) { return __x; }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_uint4    __x) { return __x; }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_uint8    __x) { return __x; }
-static simd_uint16 SIMD_CFUNC simd_uint_sat(simd_uint16   __x) { return __x; }
-static simd_uint2  SIMD_CFUNC simd_uint_sat(simd_ulong2   __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint3  SIMD_CFUNC simd_uint_sat(simd_ulong3   __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint4  SIMD_CFUNC simd_uint_sat(simd_ulong4   __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-static simd_uint8  SIMD_CFUNC simd_uint_sat(simd_ulong8   __x) { return simd_uint(simd_clamp(__x,0,0xffffffff)); }
-
-static simd_float2  SIMD_CFUNC simd_float(simd_char2    __x) { return (simd_float2)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float3  SIMD_CFUNC simd_float(simd_char3    __x) { return (simd_float3)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float4  SIMD_CFUNC simd_float(simd_char4    __x) { return (simd_float4)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float8  SIMD_CFUNC simd_float(simd_char8    __x) { return (simd_float8)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float16 SIMD_CFUNC simd_float(simd_char16   __x) { return (simd_float16)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float2  SIMD_CFUNC simd_float(simd_uchar2   __x) { return (simd_float2)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float3  SIMD_CFUNC simd_float(simd_uchar3   __x) { return (simd_float3)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float4  SIMD_CFUNC simd_float(simd_uchar4   __x) { return (simd_float4)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float8  SIMD_CFUNC simd_float(simd_uchar8   __x) { return (simd_float8)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float16 SIMD_CFUNC simd_float(simd_uchar16  __x) { return (simd_float16)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float2  SIMD_CFUNC simd_float(simd_short2   __x) { return (simd_float2)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float3  SIMD_CFUNC simd_float(simd_short3   __x) { return (simd_float3)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float4  SIMD_CFUNC simd_float(simd_short4   __x) { return (simd_float4)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float8  SIMD_CFUNC simd_float(simd_short8   __x) { return (simd_float8)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float16 SIMD_CFUNC simd_float(simd_short16  __x) { return (simd_float16)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float2  SIMD_CFUNC simd_float(simd_ushort2  __x) { return (simd_float2)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float3  SIMD_CFUNC simd_float(simd_ushort3  __x) { return (simd_float3)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float4  SIMD_CFUNC simd_float(simd_ushort4  __x) { return (simd_float4)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float8  SIMD_CFUNC simd_float(simd_ushort8  __x) { return (simd_float8)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float16 SIMD_CFUNC simd_float(simd_ushort16 __x) { return (simd_float16)(simd_int(__x) + 0x4b400000) - 0x1.8p23f; }
-static simd_float2  SIMD_CFUNC simd_float(simd_int2     __x) { return __builtin_convertvector(__x,simd_float2); }
-static simd_float3  SIMD_CFUNC simd_float(simd_int3     __x) { return __builtin_convertvector(__x,simd_float3); }
-static simd_float4  SIMD_CFUNC simd_float(simd_int4     __x) { return __builtin_convertvector(__x,simd_float4); }
-static simd_float8  SIMD_CFUNC simd_float(simd_int8     __x) { return __builtin_convertvector(__x,simd_float8); }
-static simd_float16 SIMD_CFUNC simd_float(simd_int16    __x) { return __builtin_convertvector(__x,simd_float16); }
-static simd_float2  SIMD_CFUNC simd_float(simd_uint2    __x) { return __builtin_convertvector(__x,simd_float2); }
-static simd_float3  SIMD_CFUNC simd_float(simd_uint3    __x) { return __builtin_convertvector(__x,simd_float3); }
-static simd_float4  SIMD_CFUNC simd_float(simd_uint4    __x) { return __builtin_convertvector(__x,simd_float4); }
-static simd_float8  SIMD_CFUNC simd_float(simd_uint8    __x) { return __builtin_convertvector(__x,simd_float8); }
-static simd_float16 SIMD_CFUNC simd_float(simd_uint16   __x) { return __builtin_convertvector(__x,simd_float16); }
-static simd_float2  SIMD_CFUNC simd_float(simd_float2   __x) { return __x; }
-static simd_float3  SIMD_CFUNC simd_float(simd_float3   __x) { return __x; }
-static simd_float4  SIMD_CFUNC simd_float(simd_float4   __x) { return __x; }
-static simd_float8  SIMD_CFUNC simd_float(simd_float8   __x) { return __x; }
-static simd_float16 SIMD_CFUNC simd_float(simd_float16  __x) { return __x; }
-static simd_float2  SIMD_CFUNC simd_float(simd_long2    __x) { return __builtin_convertvector(__x,simd_float2); }
-static simd_float3  SIMD_CFUNC simd_float(simd_long3    __x) { return __builtin_convertvector(__x,simd_float3); }
-static simd_float4  SIMD_CFUNC simd_float(simd_long4    __x) { return __builtin_convertvector(__x,simd_float4); }
-static simd_float8  SIMD_CFUNC simd_float(simd_long8    __x) { return __builtin_convertvector(__x,simd_float8); }
-static simd_float2  SIMD_CFUNC simd_float(simd_ulong2   __x) { return __builtin_convertvector(__x,simd_float2); }
-static simd_float3  SIMD_CFUNC simd_float(simd_ulong3   __x) { return __builtin_convertvector(__x,simd_float3); }
-static simd_float4  SIMD_CFUNC simd_float(simd_ulong4   __x) { return __builtin_convertvector(__x,simd_float4); }
-static simd_float8  SIMD_CFUNC simd_float(simd_ulong8   __x) { return __builtin_convertvector(__x,simd_float8); }
-static simd_float2  SIMD_CFUNC simd_float(simd_double2  __x) { return __builtin_convertvector(__x,simd_float2); }
-static simd_float3  SIMD_CFUNC simd_float(simd_double3  __x) { return __builtin_convertvector(__x,simd_float3); }
-static simd_float4  SIMD_CFUNC simd_float(simd_double4  __x) { return __builtin_convertvector(__x,simd_float4); }
-static simd_float8  SIMD_CFUNC simd_float(simd_double8  __x) { return __builtin_convertvector(__x,simd_float8); }
-
-static simd_long2  SIMD_CFUNC simd_long(simd_char2    __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_char3    __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_char4    __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_char8    __x) { return __builtin_convertvector(__x,simd_long8); }
-static simd_long2  SIMD_CFUNC simd_long(simd_uchar2   __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_uchar3   __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_uchar4   __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_uchar8   __x) { return __builtin_convertvector(__x,simd_long8); }
-static simd_long2  SIMD_CFUNC simd_long(simd_short2   __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_short3   __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_short4   __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_short8   __x) { return __builtin_convertvector(__x,simd_long8); }
-static simd_long2  SIMD_CFUNC simd_long(simd_ushort2  __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_ushort3  __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_ushort4  __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_ushort8  __x) { return __builtin_convertvector(__x,simd_long8); }
-static simd_long2  SIMD_CFUNC simd_long(simd_int2     __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_int3     __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_int4     __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_int8     __x) { return __builtin_convertvector(__x,simd_long8); }
-static simd_long2  SIMD_CFUNC simd_long(simd_uint2    __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_uint3    __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_uint4    __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_uint8    __x) { return __builtin_convertvector(__x,simd_long8); }
-static simd_long2  SIMD_CFUNC simd_long(simd_float2   __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_float3   __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_float4   __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_float8   __x) { return __builtin_convertvector(__x,simd_long8); }
-static simd_long2  SIMD_CFUNC simd_long(simd_long2    __x) { return __x; }
-static simd_long3  SIMD_CFUNC simd_long(simd_long3    __x) { return __x; }
-static simd_long4  SIMD_CFUNC simd_long(simd_long4    __x) { return __x; }
-static simd_long8  SIMD_CFUNC simd_long(simd_long8    __x) { return __x; }
-static simd_long2  SIMD_CFUNC simd_long(simd_ulong2   __x) { return (simd_long2)__x; }
-static simd_long3  SIMD_CFUNC simd_long(simd_ulong3   __x) { return (simd_long3)__x; }
-static simd_long4  SIMD_CFUNC simd_long(simd_ulong4   __x) { return (simd_long4)__x; }
-static simd_long8  SIMD_CFUNC simd_long(simd_ulong8   __x) { return (simd_long8)__x; }
-static simd_long2  SIMD_CFUNC simd_long(simd_double2  __x) { return __builtin_convertvector(__x,simd_long2); }
-static simd_long3  SIMD_CFUNC simd_long(simd_double3  __x) { return __builtin_convertvector(__x,simd_long3); }
-static simd_long4  SIMD_CFUNC simd_long(simd_double4  __x) { return __builtin_convertvector(__x,simd_long4); }
-static simd_long8  SIMD_CFUNC simd_long(simd_double8  __x) { return __builtin_convertvector(__x,simd_long8); }
-    
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_char2    __x) { return simd_long(__x); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_char3    __x) { return simd_long(__x); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_char4    __x) { return simd_long(__x); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_char8    __x) { return simd_long(__x); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_short2   __x) { return simd_long(__x); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_short3   __x) { return simd_long(__x); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_short4   __x) { return simd_long(__x); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_short8   __x) { return simd_long(__x); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_int2     __x) { return simd_long(__x); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_int3     __x) { return simd_long(__x); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_int4     __x) { return simd_long(__x); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_int8     __x) { return simd_long(__x); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_float2   __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63f)), 0x7fffffffffffffff, simd_long(__x >= 0x1.0p63f)); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_float3   __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63f)), 0x7fffffffffffffff, simd_long(__x >= 0x1.0p63f)); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_float4   __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63f)), 0x7fffffffffffffff, simd_long(__x >= 0x1.0p63f)); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_float8   __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63f)), 0x7fffffffffffffff, simd_long(__x >= 0x1.0p63f)); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_long2    __x) { return __x; }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_long3    __x) { return __x; }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_long4    __x) { return __x; }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_long8    __x) { return __x; }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_double2  __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63)), 0x7fffffffffffffff, __x >= 0x1.0p63); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_double3  __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63)), 0x7fffffffffffffff, __x >= 0x1.0p63); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_double4  __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63)), 0x7fffffffffffffff, __x >= 0x1.0p63); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_double8  __x) { return simd_bitselect(simd_long(simd_max(__x,-0x1.0p63)), 0x7fffffffffffffff, __x >= 0x1.0p63); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_uchar2   __x) { return simd_long(__x); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_uchar3   __x) { return simd_long(__x); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_uchar4   __x) { return simd_long(__x); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_uchar8   __x) { return simd_long(__x); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_ushort2  __x) { return simd_long(__x); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_ushort3  __x) { return simd_long(__x); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_ushort4  __x) { return simd_long(__x); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_ushort8  __x) { return simd_long(__x); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_uint2    __x) { return simd_long(__x); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_uint3    __x) { return simd_long(__x); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_uint4    __x) { return simd_long(__x); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_uint8    __x) { return simd_long(__x); }
-static simd_long2  SIMD_CFUNC simd_long_sat(simd_ulong2   __x) { return simd_long(simd_min(__x,0x7fffffffffffffff)); }
-static simd_long3  SIMD_CFUNC simd_long_sat(simd_ulong3   __x) { return simd_long(simd_min(__x,0x7fffffffffffffff)); }
-static simd_long4  SIMD_CFUNC simd_long_sat(simd_ulong4   __x) { return simd_long(simd_min(__x,0x7fffffffffffffff)); }
-static simd_long8  SIMD_CFUNC simd_long_sat(simd_ulong8   __x) { return simd_long(simd_min(__x,0x7fffffffffffffff)); }
-
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_char2    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_char3    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_char4    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_char8    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_uchar2   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_uchar3   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_uchar4   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_uchar8   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_short2   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_short3   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_short4   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_short8   __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_ushort2  __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_ushort3  __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_ushort4  __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_ushort8  __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_int2     __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_int3     __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_int4     __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_int8     __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_uint2    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_uint3    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_uint4    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_uint8    __x) { return simd_ulong(simd_long(__x)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_float2   __x) { simd_int2 __big = __x >= 0x1.0p63f; return simd_ulong(simd_long(__x - simd_bitselect((simd_float2)0,0x1.0p63f,__big))) + simd_bitselect((simd_ulong2)0,0x8000000000000000,simd_long(__big)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_float3   __x) { simd_int3 __big = __x >= 0x1.0p63f; return simd_ulong(simd_long(__x - simd_bitselect((simd_float3)0,0x1.0p63f,__big))) + simd_bitselect((simd_ulong3)0,0x8000000000000000,simd_long(__big)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_float4   __x) { simd_int4 __big = __x >= 0x1.0p63f; return simd_ulong(simd_long(__x - simd_bitselect((simd_float4)0,0x1.0p63f,__big))) + simd_bitselect((simd_ulong4)0,0x8000000000000000,simd_long(__big)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_float8   __x) { simd_int8 __big = __x >= 0x1.0p63f; return simd_ulong(simd_long(__x - simd_bitselect((simd_float8)0,0x1.0p63f,__big))) + simd_bitselect((simd_ulong8)0,0x8000000000000000,simd_long(__big)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_long2    __x) { return (simd_ulong2)__x; }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_long3    __x) { return (simd_ulong3)__x; }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_long4    __x) { return (simd_ulong4)__x; }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_long8    __x) { return (simd_ulong8)__x; }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_ulong2   __x) { return __x; }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_ulong3   __x) { return __x; }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_ulong4   __x) { return __x; }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_ulong8   __x) { return __x; }
-static simd_ulong2  SIMD_CFUNC simd_ulong(simd_double2  __x) { simd_long2 __big = __x >= 0x1.0p63; return simd_ulong(simd_long(__x - simd_bitselect((simd_double2)0,0x1.0p63,__big))) + simd_bitselect((simd_ulong2)0,0x8000000000000000,__big); }
-static simd_ulong3  SIMD_CFUNC simd_ulong(simd_double3  __x) { simd_long3 __big = __x >= 0x1.0p63; return simd_ulong(simd_long(__x - simd_bitselect((simd_double3)0,0x1.0p63,__big))) + simd_bitselect((simd_ulong3)0,0x8000000000000000,__big); }
-static simd_ulong4  SIMD_CFUNC simd_ulong(simd_double4  __x) { simd_long4 __big = __x >= 0x1.0p63; return simd_ulong(simd_long(__x - simd_bitselect((simd_double4)0,0x1.0p63,__big))) + simd_bitselect((simd_ulong4)0,0x8000000000000000,__big); }
-static simd_ulong8  SIMD_CFUNC simd_ulong(simd_double8  __x) { simd_long8 __big = __x >= 0x1.0p63; return simd_ulong(simd_long(__x - simd_bitselect((simd_double8)0,0x1.0p63,__big))) + simd_bitselect((simd_ulong8)0,0x8000000000000000,__big); }
-    
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_char2    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_char3    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_char4    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_char8    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_short2   __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_short3   __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_short4   __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_short8   __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_int2     __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_int3     __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_int4     __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_int8     __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_float2   __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.f)), 0xffffffffffffffff, simd_long(__x >= 0x1.0p64f)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_float3   __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.f)), 0xffffffffffffffff, simd_long(__x >= 0x1.0p64f)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_float4   __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.f)), 0xffffffffffffffff, simd_long(__x >= 0x1.0p64f)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_float8   __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.f)), 0xffffffffffffffff, simd_long(__x >= 0x1.0p64f)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_long2    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_long3    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_long4    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_long8    __x) { return simd_ulong(simd_max(__x,0)); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_double2  __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.0)), 0xffffffffffffffff, __x >= 0x1.0p64); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_double3  __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.0)), 0xffffffffffffffff, __x >= 0x1.0p64); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_double4  __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.0)), 0xffffffffffffffff, __x >= 0x1.0p64); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_double8  __x) { return simd_bitselect(simd_ulong(simd_max(__x,0.0)), 0xffffffffffffffff, __x >= 0x1.0p64); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_uchar2   __x) { return simd_ulong(__x); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_uchar3   __x) { return simd_ulong(__x); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_uchar4   __x) { return simd_ulong(__x); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_uchar8   __x) { return simd_ulong(__x); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_ushort2  __x) { return simd_ulong(__x); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_ushort3  __x) { return simd_ulong(__x); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_ushort4  __x) { return simd_ulong(__x); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_ushort8  __x) { return simd_ulong(__x); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_uint2    __x) { return simd_ulong(__x); }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_uint3    __x) { return simd_ulong(__x); }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_uint4    __x) { return simd_ulong(__x); }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_uint8    __x) { return simd_ulong(__x); }
-static simd_ulong2  SIMD_CFUNC simd_ulong_sat(simd_ulong2   __x) { return __x; }
-static simd_ulong3  SIMD_CFUNC simd_ulong_sat(simd_ulong3   __x) { return __x; }
-static simd_ulong4  SIMD_CFUNC simd_ulong_sat(simd_ulong4   __x) { return __x; }
-static simd_ulong8  SIMD_CFUNC simd_ulong_sat(simd_ulong8   __x) { return __x; }
-
-static simd_double2  SIMD_CFUNC simd_double(simd_char2    __x) { return simd_double(simd_int(__x)); }
-static simd_double3  SIMD_CFUNC simd_double(simd_char3    __x) { return simd_double(simd_int(__x)); }
-static simd_double4  SIMD_CFUNC simd_double(simd_char4    __x) { return simd_double(simd_int(__x)); }
-static simd_double8  SIMD_CFUNC simd_double(simd_char8    __x) { return simd_double(simd_int(__x)); }
-static simd_double2  SIMD_CFUNC simd_double(simd_uchar2   __x) { return simd_double(simd_int(__x)); }
-static simd_double3  SIMD_CFUNC simd_double(simd_uchar3   __x) { return simd_double(simd_int(__x)); }
-static simd_double4  SIMD_CFUNC simd_double(simd_uchar4   __x) { return simd_double(simd_int(__x)); }
-static simd_double8  SIMD_CFUNC simd_double(simd_uchar8   __x) { return simd_double(simd_int(__x)); }
-static simd_double2  SIMD_CFUNC simd_double(simd_short2   __x) { return simd_double(simd_int(__x)); }
-static simd_double3  SIMD_CFUNC simd_double(simd_short3   __x) { return simd_double(simd_int(__x)); }
-static simd_double4  SIMD_CFUNC simd_double(simd_short4   __x) { return simd_double(simd_int(__x)); }
-static simd_double8  SIMD_CFUNC simd_double(simd_short8   __x) { return simd_double(simd_int(__x)); }
-static simd_double2  SIMD_CFUNC simd_double(simd_ushort2  __x) { return simd_double(simd_int(__x)); }
-static simd_double3  SIMD_CFUNC simd_double(simd_ushort3  __x) { return simd_double(simd_int(__x)); }
-static simd_double4  SIMD_CFUNC simd_double(simd_ushort4  __x) { return simd_double(simd_int(__x)); }
-static simd_double8  SIMD_CFUNC simd_double(simd_ushort8  __x) { return simd_double(simd_int(__x)); }
-static simd_double2  SIMD_CFUNC simd_double(simd_int2     __x) { return __builtin_convertvector(__x, simd_double2); }
-static simd_double3  SIMD_CFUNC simd_double(simd_int3     __x) { return __builtin_convertvector(__x, simd_double3); }
-static simd_double4  SIMD_CFUNC simd_double(simd_int4     __x) { return __builtin_convertvector(__x, simd_double4); }
-static simd_double8  SIMD_CFUNC simd_double(simd_int8     __x) { return __builtin_convertvector(__x, simd_double8); }
-static simd_double2  SIMD_CFUNC simd_double(simd_uint2    __x) { return __builtin_convertvector(__x, simd_double2); }
-static simd_double3  SIMD_CFUNC simd_double(simd_uint3    __x) { return __builtin_convertvector(__x, simd_double3); }
-static simd_double4  SIMD_CFUNC simd_double(simd_uint4    __x) { return __builtin_convertvector(__x, simd_double4); }
-static simd_double8  SIMD_CFUNC simd_double(simd_uint8    __x) { return __builtin_convertvector(__x, simd_double8); }
-static simd_double2  SIMD_CFUNC simd_double(simd_float2   __x) { return __builtin_convertvector(__x, simd_double2); }
-static simd_double3  SIMD_CFUNC simd_double(simd_float3   __x) { return __builtin_convertvector(__x, simd_double3); }
-static simd_double4  SIMD_CFUNC simd_double(simd_float4   __x) { return __builtin_convertvector(__x, simd_double4); }
-static simd_double8  SIMD_CFUNC simd_double(simd_float8   __x) { return __builtin_convertvector(__x, simd_double8); }
-static simd_double2  SIMD_CFUNC simd_double(simd_long2    __x) { return __builtin_convertvector(__x, simd_double2); }
-static simd_double3  SIMD_CFUNC simd_double(simd_long3    __x) { return __builtin_convertvector(__x, simd_double3); }
-static simd_double4  SIMD_CFUNC simd_double(simd_long4    __x) { return __builtin_convertvector(__x, simd_double4); }
-static simd_double8  SIMD_CFUNC simd_double(simd_long8    __x) { return __builtin_convertvector(__x, simd_double8); }
-static simd_double2  SIMD_CFUNC simd_double(simd_ulong2   __x) { return __builtin_convertvector(__x, simd_double2); }
-static simd_double3  SIMD_CFUNC simd_double(simd_ulong3   __x) { return __builtin_convertvector(__x, simd_double3); }
-static simd_double4  SIMD_CFUNC simd_double(simd_ulong4   __x) { return __builtin_convertvector(__x, simd_double4); }
-static simd_double8  SIMD_CFUNC simd_double(simd_ulong8   __x) { return __builtin_convertvector(__x, simd_double8); }
-static simd_double2  SIMD_CFUNC simd_double(simd_double2  __x) { return __builtin_convertvector(__x, simd_double2); }
-static simd_double3  SIMD_CFUNC simd_double(simd_double3  __x) { return __builtin_convertvector(__x, simd_double3); }
-static simd_double4  SIMD_CFUNC simd_double(simd_double4  __x) { return __builtin_convertvector(__x, simd_double4); }
-static simd_double8  SIMD_CFUNC simd_double(simd_double8  __x) { return __builtin_convertvector(__x, simd_double8); }
-
-#ifdef __cplusplus
-}
-#endif
-#endif // SIMD_COMPILER_HAS_REQUIRED_FEATURES
-#endif // __SIMD_CONVERSION_HEADER__
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/simd/logic.h b/lib/libc/include/x86_64-macos.10-none/simd/logic.h
deleted file mode 100644
index 38bd9bf58c..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/simd/logic.h
+++ /dev/null
@@ -1,1315 +0,0 @@
-/*! @header
- *  The interfaces declared in this header provide logical and bitwise
- *  operations on vectors.  Some of these function operate elementwise,
- *  and some produce a scalar result that depends on all lanes of the input.
- *
- *  For functions returning a boolean value, the return type in C and
- *  Objective-C is _Bool; for C++ it is bool.
- *
- *      Function                    Result
- *      ------------------------------------------------------------------
- *      simd_all(comparison)        True if and only if the comparison is true
- *                                  in every vector lane.  e.g.:
- *
- *                                      if (simd_all(x == 0.0f)) {
- *                                          // executed if every lane of x
- *                                          // contains zero.
- *                                      }
- *
- *                                  The precise function of simd_all is to
- *                                  return the high-order bit of the result
- *                                  of a horizontal bitwise AND of all vector
- *                                  lanes.
- *
- *      simd_any(comparison)        True if and only if the comparison is true
- *                                  in at least one vector lane.  e.g.:
- *
- *                                      if (simd_any(x < 0.0f)) {
- *                                          // executed if any lane of x
- *                                          // contains a negative value.
- *                                      }
- *
- *                                  The precise function of simd_all is to
- *                                  return the high-order bit of the result
- *                                  of a horizontal bitwise OR of all vector
- *                                  lanes.
- *
- *      simd_select(x,y,mask)       For each lane in the result, selects the
- *                                  corresponding element of x if the high-
- *                                  order bit of the corresponding element of
- *                                  mask is 0, and the corresponding element
- *                                  of y otherwise.
- *
- *      simd_bitselect(x,y,mask)    For each bit in the result, selects the
- *                                  corresponding bit of x if the corresponding
- *                                  bit of mask is clear, and the corresponding
- *                                  of y otherwise.
- *
- *  In C++, these functions are available under the simd:: namespace:
- *
- *      C++ Function                    Equivalent C Function
- *      --------------------------------------------------------------------
- *      simd::all(comparison)           simd_all(comparison)
- *      simd::any(comparison)           simd_any(comparison)
- *      simd::select(x,y,mask)          simd_select(x,y,mask)
- *      simd::bitselect(x,y,mask)       simd_bitselect(x,y,mask)
- *
- *  @copyright 2014-2017 Apple, Inc. All rights reserved.
- *  @unsorted                                                                 */
-
-#ifndef SIMD_LOGIC_HEADER
-#define SIMD_LOGIC_HEADER
-
-#include <simd/base.h>
-#if SIMD_COMPILER_HAS_REQUIRED_FEATURES
-#include <simd/vector_make.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_char2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_char3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_char4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_char8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_char16 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_char32 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_char64 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar16 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar32 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar64 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_short2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_short3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_short4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_short8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_short16 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_short32 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort16 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort32 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_int2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_int3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_int4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_int8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_int16 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint16 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_long2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_long3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_long4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_long8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong2 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong3 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong4 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong8 x);
-/*! @abstract True if and only if the high-order bit of any lane of the
- *  vector is set.
- *  @discussion Deprecated. Use simd_any instead.                             */
-#define vector_any simd_any
-
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_char2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_char3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_char4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_char8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_char16 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_char32 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_char64 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar16 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar32 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar64 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_short2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_short3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_short4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_short8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_short16 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_short32 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort16 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort32 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_int2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_int3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_int4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_int8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_int16 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint16 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_long2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_long3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_long4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_long8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong2 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong3 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong4 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.                                                            */
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong8 x);
-/*! @abstract True if and only if the high-order bit of every lane of the
- *  vector is set.
- *  @discussion Deprecated. Use simd_all instead.                             */
-#define vector_all simd_all
-
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_float2 simd_select(simd_float2 x, simd_float2 y, simd_int2 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_float3 simd_select(simd_float3 x, simd_float3 y, simd_int3 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_float4 simd_select(simd_float4 x, simd_float4 y, simd_int4 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_float8 simd_select(simd_float8 x, simd_float8 y, simd_int8 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_float16 simd_select(simd_float16 x, simd_float16 y, simd_int16 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_double2 simd_select(simd_double2 x, simd_double2 y, simd_long2 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_double3 simd_select(simd_double3 x, simd_double3 y, simd_long3 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_double4 simd_select(simd_double4 x, simd_double4 y, simd_long4 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.                                     */
-static inline SIMD_CFUNC simd_double8 simd_select(simd_double8 x, simd_double8 y, simd_long8 mask);
-/*! @abstract For each lane in the result, selects the corresponding element
- *  of x or y according to whether the high-order bit of the corresponding
- *  lane of mask is 0 or 1, respectively.
- *  @discussion Deprecated. Use simd_select instead.                          */
-#define vector_select simd_select
-  
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_char2 simd_bitselect(simd_char2 x, simd_char2 y, simd_char2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_char3 simd_bitselect(simd_char3 x, simd_char3 y, simd_char3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_char4 simd_bitselect(simd_char4 x, simd_char4 y, simd_char4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_char8 simd_bitselect(simd_char8 x, simd_char8 y, simd_char8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_char16 simd_bitselect(simd_char16 x, simd_char16 y, simd_char16 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_char32 simd_bitselect(simd_char32 x, simd_char32 y, simd_char32 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_char64 simd_bitselect(simd_char64 x, simd_char64 y, simd_char64 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uchar2 simd_bitselect(simd_uchar2 x, simd_uchar2 y, simd_char2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uchar3 simd_bitselect(simd_uchar3 x, simd_uchar3 y, simd_char3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uchar4 simd_bitselect(simd_uchar4 x, simd_uchar4 y, simd_char4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uchar8 simd_bitselect(simd_uchar8 x, simd_uchar8 y, simd_char8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uchar16 simd_bitselect(simd_uchar16 x, simd_uchar16 y, simd_char16 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uchar32 simd_bitselect(simd_uchar32 x, simd_uchar32 y, simd_char32 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uchar64 simd_bitselect(simd_uchar64 x, simd_uchar64 y, simd_char64 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_short2 simd_bitselect(simd_short2 x, simd_short2 y, simd_short2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_short3 simd_bitselect(simd_short3 x, simd_short3 y, simd_short3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_short4 simd_bitselect(simd_short4 x, simd_short4 y, simd_short4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_short8 simd_bitselect(simd_short8 x, simd_short8 y, simd_short8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_short16 simd_bitselect(simd_short16 x, simd_short16 y, simd_short16 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_short32 simd_bitselect(simd_short32 x, simd_short32 y, simd_short32 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ushort2 simd_bitselect(simd_ushort2 x, simd_ushort2 y, simd_short2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ushort3 simd_bitselect(simd_ushort3 x, simd_ushort3 y, simd_short3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ushort4 simd_bitselect(simd_ushort4 x, simd_ushort4 y, simd_short4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ushort8 simd_bitselect(simd_ushort8 x, simd_ushort8 y, simd_short8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ushort16 simd_bitselect(simd_ushort16 x, simd_ushort16 y, simd_short16 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ushort32 simd_bitselect(simd_ushort32 x, simd_ushort32 y, simd_short32 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_int2 simd_bitselect(simd_int2 x, simd_int2 y, simd_int2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_int3 simd_bitselect(simd_int3 x, simd_int3 y, simd_int3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_int4 simd_bitselect(simd_int4 x, simd_int4 y, simd_int4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_int8 simd_bitselect(simd_int8 x, simd_int8 y, simd_int8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_int16 simd_bitselect(simd_int16 x, simd_int16 y, simd_int16 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uint2 simd_bitselect(simd_uint2 x, simd_uint2 y, simd_int2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uint3 simd_bitselect(simd_uint3 x, simd_uint3 y, simd_int3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uint4 simd_bitselect(simd_uint4 x, simd_uint4 y, simd_int4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uint8 simd_bitselect(simd_uint8 x, simd_uint8 y, simd_int8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_uint16 simd_bitselect(simd_uint16 x, simd_uint16 y, simd_int16 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_float2 simd_bitselect(simd_float2 x, simd_float2 y, simd_int2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_float3 simd_bitselect(simd_float3 x, simd_float3 y, simd_int3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_float4 simd_bitselect(simd_float4 x, simd_float4 y, simd_int4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_float8 simd_bitselect(simd_float8 x, simd_float8 y, simd_int8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_float16 simd_bitselect(simd_float16 x, simd_float16 y, simd_int16 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_long2 simd_bitselect(simd_long2 x, simd_long2 y, simd_long2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_long3 simd_bitselect(simd_long3 x, simd_long3 y, simd_long3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_long4 simd_bitselect(simd_long4 x, simd_long4 y, simd_long4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_long8 simd_bitselect(simd_long8 x, simd_long8 y, simd_long8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ulong2 simd_bitselect(simd_ulong2 x, simd_ulong2 y, simd_long2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ulong3 simd_bitselect(simd_ulong3 x, simd_ulong3 y, simd_long3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ulong4 simd_bitselect(simd_ulong4 x, simd_ulong4 y, simd_long4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_ulong8 simd_bitselect(simd_ulong8 x, simd_ulong8 y, simd_long8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_double2 simd_bitselect(simd_double2 x, simd_double2 y, simd_long2 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_double3 simd_bitselect(simd_double3 x, simd_double3 y, simd_long3 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_double4 simd_bitselect(simd_double4 x, simd_double4 y, simd_long4 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.                                                             */
-static inline SIMD_CFUNC simd_double8 simd_bitselect(simd_double8 x, simd_double8 y, simd_long8 mask);
-/*! @abstract For each bit in the result, selects the corresponding bit of x
- *  or y according to whether the corresponding bit of mask is 0 or 1,
- *  respectively.
- *  @discussion Deprecated. Use simd_bitselect instead.                       */
-#define vector_bitselect simd_bitselect
-
-#ifdef __cplusplus
-} /* extern "C" */
-
-namespace simd {
-  /*! @abstract True if and only if the high-order bit of every lane is set.  */
-  template <typename inttypeN> static SIMD_CPPFUNC simd_bool all(const inttypeN predicate) { return ::simd_all(predicate); }
-  /*! @abstract True if and only if the high-order bit of any lane is set.    */
-  template <typename inttypeN> static SIMD_CPPFUNC simd_bool any(const inttypeN predicate) { return ::simd_any(predicate); }
-  /*! @abstract Each lane of the result is selected from the corresponding lane
-   *  of x or y according to whether the high-order bit of the corresponding
-   *  lane of mask is 0 or 1, respectively.                                   */
-  template <typename inttypeN, typename fptypeN> static SIMD_CPPFUNC fptypeN select(const fptypeN x, const fptypeN y, const inttypeN predicate) { return ::simd_select(x,y,predicate); }
-  /*! @abstract For each bit in the result, selects the corresponding bit of x
-   *  or y according to whether the corresponding bit of mask is 0 or 1,
-   *  respectively.                                                           */
-  template <typename inttypeN, typename typeN> static SIMD_CPPFUNC typeN bitselect(const typeN x, const typeN y, const inttypeN mask) { return ::simd_bitselect(x,y,mask); }
-}
-
-extern "C" {
-#endif /* __cplusplus */
-
-#pragma mark - Implementations
-
-static inline SIMD_CFUNC simd_bool simd_any(simd_char2 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0x3);
-#elif defined __arm64__
-  return simd_any(x.xyxy);
-#else
-  union { uint16_t i; simd_char2 v; } u = { .v = x };
-  return (u.i & 0x8080);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_char3 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0x7);
-#elif defined __arm64__
-  return simd_any(x.xyzz);
-#else
-  union { uint32_t i; simd_char3 v; } u = { .v = x };
-  return (u.i & 0x808080);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_char4 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0xf);
-#elif defined __arm64__
-  return simd_any(x.xyzwxyzw);
-#else
-  union { uint32_t i; simd_char4 v; } u = { .v = x };
-  return (u.i & 0x80808080);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_char8 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0xff);
-#elif defined __arm64__
-  return vmaxv_u8(x) & 0x80;
-#else
-  union { uint64_t i; simd_char8 v; } u = { .v = x };
-  return (u.i & 0x8080808080808080);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_char16 x) {
-#if defined __SSE2__
-  return _mm_movemask_epi8(x);
-#elif defined __arm64__
-  return vmaxvq_u8(x) & 0x80;
-#else
-  return simd_any(x.lo | x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_char32 x) {
-#if defined __AVX2__
-  return _mm256_movemask_epi8(x);
-#else
-  return simd_any(x.lo | x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_char64 x) {
-  return simd_any(x.lo | x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar2 x) {
-  return simd_any((simd_char2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar3 x) {
-  return simd_any((simd_char3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar4 x) {
-  return simd_any((simd_char4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar8 x) {
-  return simd_any((simd_char8)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar16 x) {
-  return simd_any((simd_char16)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar32 x) {
-  return simd_any((simd_char32)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uchar64 x) {
-  return simd_any((simd_char64)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_short2 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_short8_undef(x)) & 0xa);
-#elif defined __arm64__
-  return simd_any(x.xyxy);
-#else
-  union { uint32_t i; simd_short2 v; } u = { .v = x };
-  return (u.i & 0x80008000);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_short3 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_short8_undef(x)) & 0x2a);
-#elif defined __arm64__
-  return simd_any(x.xyzz);
-#else
-  union { uint64_t i; simd_short3 v; } u = { .v = x };
-  return (u.i & 0x800080008000);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_short4 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_short8_undef(x)) & 0xaa);
-#elif defined __arm64__
-  return vmaxv_u16(x) & 0x8000;
-#else
-  union { uint64_t i; simd_short4 v; } u = { .v = x };
-  return (u.i & 0x8000800080008000);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_short8 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(x) & 0xaaaa);
-#elif defined __arm64__
-  return vmaxvq_u16(x) & 0x8000;
-#else
-  return simd_any(x.lo | x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_short16 x) {
-#if defined __AVX2__
-  return (_mm256_movemask_epi8(x) & 0xaaaaaaaa);
-#else
-  return simd_any(x.lo | x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_short32 x) {
-  return simd_any(x.lo | x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort2 x) {
-  return simd_any((simd_short2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort3 x) {
-  return simd_any((simd_short3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort4 x) {
-  return simd_any((simd_short4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort8 x) {
-  return simd_any((simd_short8)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort16 x) {
-  return simd_any((simd_short16)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ushort32 x) {
-  return simd_any((simd_short32)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_int2 x) {
-#if defined __SSE2__
-  return (_mm_movemask_ps(simd_make_int4_undef(x)) & 0x3);
-#elif defined __arm64__
-  return vmaxv_u32(x) & 0x80000000;
-#else
-  union { uint64_t i; simd_int2 v; } u = { .v = x };
-  return (u.i & 0x8000000080000000);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_int3 x) {
-#if defined __SSE2__
-  return (_mm_movemask_ps(simd_make_int4_undef(x)) & 0x7);
-#elif defined __arm64__
-  return simd_any(x.xyzz);
-#else
-  return (x.x | x.y | x.z) & 0x80000000;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_int4 x) {
-#if defined __SSE2__
-  return _mm_movemask_ps(x);
-#elif defined __arm64__
-  return vmaxvq_u32(x) & 0x80000000;
-#else
-  return simd_any(x.lo | x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_int8 x) {
-#if defined __AVX__
-  return _mm256_movemask_ps(x);
-#else
-  return simd_any(x.lo | x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_int16 x) {
-  return simd_any(x.lo | x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint2 x) {
-  return simd_any((simd_int2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint3 x) {
-  return simd_any((simd_int3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint4 x) {
-  return simd_any((simd_int4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint8 x) {
-  return simd_any((simd_int8)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_uint16 x) {
-  return simd_any((simd_int16)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_long2 x) {
-#if defined __SSE2__
-  return _mm_movemask_pd(x);
-#elif defined __arm64__
-  return (x.x | x.y) & 0x8000000000000000U;
-#else
-  return (x.x | x.y) & 0x8000000000000000U;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_long3 x) {
-#if defined __AVX__
-  return (_mm256_movemask_pd(simd_make_long4_undef(x)) & 0x7);
-#else
-  return (x.x | x.y | x.z) & 0x8000000000000000U;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_long4 x) {
-#if defined __AVX__
-  return _mm256_movemask_pd(x);
-#else
-  return simd_any(x.lo | x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_long8 x) {
-  return simd_any(x.lo | x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong2 x) {
-  return simd_any((simd_long2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong3 x) {
-  return simd_any((simd_long3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong4 x) {
-  return simd_any((simd_long4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_any(simd_ulong8 x) {
-  return simd_any((simd_long8)x);
-}
-  
-static inline SIMD_CFUNC simd_bool simd_all(simd_char2 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0x3) == 0x3;
-#elif defined __arm64__
-  return simd_all(x.xyxy);
-#else
-  union { uint16_t i; simd_char2 v; } u = { .v = x };
-  return (u.i & 0x8080) == 0x8080;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_char3 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0x7) == 0x7;
-#elif defined __arm64__
-  return simd_all(x.xyzz);
-#else
-  union { uint32_t i; simd_char3 v; } u = { .v = x };
-  return (u.i & 0x808080) == 0x808080;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_char4 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0xf) == 0xf;
-#elif defined __arm64__
-  return simd_all(x.xyzwxyzw);
-#else
-  union { uint32_t i; simd_char4 v; } u = { .v = x };
-  return (u.i & 0x80808080) == 0x80808080;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_char8 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_char16_undef(x)) & 0xff) == 0xff;
-#elif defined __arm64__
-  return vminv_u8(x) & 0x80;
-#else
-  union { uint64_t i; simd_char8 v; } u = { .v = x };
-  return (u.i & 0x8080808080808080) == 0x8080808080808080;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_char16 x) {
-#if defined __SSE2__
-  return _mm_movemask_epi8(x) == 0xffff;
-#elif defined __arm64__
-  return vminvq_u8(x) & 0x80;
-#else
-  return simd_all(x.lo & x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_char32 x) {
-#if defined __AVX2__
-  return _mm256_movemask_epi8(x) == 0xffffffff;
-#else
-  return simd_all(x.lo & x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_char64 x) {
-  return simd_all(x.lo & x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar2 x) {
-  return simd_all((simd_char2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar3 x) {
-  return simd_all((simd_char3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar4 x) {
-  return simd_all((simd_char4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar8 x) {
-  return simd_all((simd_char8)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar16 x) {
-  return simd_all((simd_char16)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar32 x) {
-  return simd_all((simd_char32)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uchar64 x) {
-  return simd_all((simd_char64)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_short2 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_short8_undef(x)) & 0xa) == 0xa;
-#elif defined __arm64__
-  return simd_all(x.xyxy);
-#else
-  union { uint32_t i; simd_short2 v; } u = { .v = x };
-  return (u.i & 0x80008000) == 0x80008000;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_short3 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_short8_undef(x)) & 0x2a) == 0x2a;
-#elif defined __arm64__
-  return simd_all(x.xyzz);
-#else
-  union { uint64_t i; simd_short3 v; } u = { .v = x };
-  return (u.i & 0x800080008000) == 0x800080008000;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_short4 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(simd_make_short8_undef(x)) & 0xaa) == 0xaa;
-#elif defined __arm64__
-  return vminv_u16(x) & 0x8000;
-#else
-  union { uint64_t i; simd_short4 v; } u = { .v = x };
-  return (u.i & 0x8000800080008000) == 0x8000800080008000;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_short8 x) {
-#if defined __SSE2__
-  return (_mm_movemask_epi8(x) & 0xaaaa) == 0xaaaa;
-#elif defined __arm64__
-  return vminvq_u16(x) & 0x8000;
-#else
-  return simd_all(x.lo & x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_short16 x) {
-#if defined __AVX2__
-  return (_mm256_movemask_epi8(x) & 0xaaaaaaaa) == 0xaaaaaaaa;
-#else
-  return simd_all(x.lo & x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_short32 x) {
-  return simd_all(x.lo & x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort2 x) {
-  return simd_all((simd_short2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort3 x) {
-  return simd_all((simd_short3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort4 x) {
-  return simd_all((simd_short4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort8 x) {
-  return simd_all((simd_short8)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort16 x) {
-  return simd_all((simd_short16)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ushort32 x) {
-  return simd_all((simd_short32)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_int2 x) {
-#if defined __SSE2__
-  return (_mm_movemask_ps(simd_make_int4_undef(x)) & 0x3) == 0x3;
-#elif defined __arm64__
-  return vminv_u32(x) & 0x80000000;
-#else
-  union { uint64_t i; simd_int2 v; } u = { .v = x };
-  return (u.i & 0x8000000080000000) == 0x8000000080000000;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_int3 x) {
-#if defined __SSE2__
-  return (_mm_movemask_ps(simd_make_int4_undef(x)) & 0x7) == 0x7;
-#elif defined __arm64__
-  return simd_all(x.xyzz);
-#else
-  return (x.x & x.y & x.z) & 0x80000000;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_int4 x) {
-#if defined __SSE2__
-  return _mm_movemask_ps(x) == 0xf;
-#elif defined __arm64__
-  return vminvq_u32(x) & 0x80000000;
-#else
-  return simd_all(x.lo & x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_int8 x) {
-#if defined __AVX__
-  return _mm256_movemask_ps(x) == 0xff;
-#else
-  return simd_all(x.lo & x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_int16 x) {
-  return simd_all(x.lo & x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint2 x) {
-  return simd_all((simd_int2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint3 x) {
-  return simd_all((simd_int3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint4 x) {
-  return simd_all((simd_int4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint8 x) {
-  return simd_all((simd_int8)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_uint16 x) {
-  return simd_all((simd_int16)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_long2 x) {
-#if defined __SSE2__
-  return _mm_movemask_pd(x) == 0x3;
-#elif defined __arm64__
-  return (x.x & x.y) & 0x8000000000000000U;
-#else
-  return (x.x & x.y) & 0x8000000000000000U;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_long3 x) {
-#if defined __AVX__
-  return (_mm256_movemask_pd(simd_make_long4_undef(x)) & 0x7) == 0x7;
-#else
-  return (x.x & x.y & x.z) & 0x8000000000000000U;
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_long4 x) {
-#if defined __AVX__
-  return _mm256_movemask_pd(x) == 0xf;
-#else
-  return simd_all(x.lo & x.hi);
-#endif
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_long8 x) {
-  return simd_all(x.lo & x.hi);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong2 x) {
-  return simd_all((simd_long2)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong3 x) {
-  return simd_all((simd_long3)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong4 x) {
-  return simd_all((simd_long4)x);
-}
-static inline SIMD_CFUNC simd_bool simd_all(simd_ulong8 x) {
-  return simd_all((simd_long8)x);
-}
-  
-static inline SIMD_CFUNC simd_float2 simd_select(simd_float2 x, simd_float2 y, simd_int2 mask) {
-  return simd_make_float2(simd_select(simd_make_float4_undef(x), simd_make_float4_undef(y), simd_make_int4_undef(mask)));
-}
-static inline SIMD_CFUNC simd_float3 simd_select(simd_float3 x, simd_float3 y, simd_int3 mask) {
-  return simd_make_float3(simd_select(simd_make_float4_undef(x), simd_make_float4_undef(y), simd_make_int4_undef(mask)));
-}
-static inline SIMD_CFUNC simd_float4 simd_select(simd_float4 x, simd_float4 y, simd_int4 mask) {
-#if defined __SSE4_1__
-  return _mm_blendv_ps(x, y, mask);
-#else
-  return simd_bitselect(x, y, mask >> 31);
-#endif
-}
-static inline SIMD_CFUNC simd_float8 simd_select(simd_float8 x, simd_float8 y, simd_int8 mask) {
-#if defined __AVX__
-  return _mm256_blendv_ps(x, y, mask);
-#else
-  return simd_bitselect(x, y, mask >> 31);
-#endif
-}
-static inline SIMD_CFUNC simd_float16 simd_select(simd_float16 x, simd_float16 y, simd_int16 mask) {
-  return simd_bitselect(x, y, mask >> 31);
-}
-static inline SIMD_CFUNC simd_double2 simd_select(simd_double2 x, simd_double2 y, simd_long2 mask) {
-#if defined __SSE4_1__
-  return _mm_blendv_pd(x, y, mask);
-#else
-  return simd_bitselect(x, y, mask >> 63);
-#endif
-}
-static inline SIMD_CFUNC simd_double3 simd_select(simd_double3 x, simd_double3 y, simd_long3 mask) {
-  return simd_make_double3(simd_select(simd_make_double4_undef(x), simd_make_double4_undef(y), simd_make_long4_undef(mask)));
-}
-static inline SIMD_CFUNC simd_double4 simd_select(simd_double4 x, simd_double4 y, simd_long4 mask) {
-#if defined __AVX__
-  return _mm256_blendv_pd(x, y, mask);
-#else
-  return simd_bitselect(x, y, mask >> 63);
-#endif
-}
-static inline SIMD_CFUNC simd_double8 simd_select(simd_double8 x, simd_double8 y, simd_long8 mask) {
-  return simd_bitselect(x, y, mask >> 63);
-}
-  
-static inline SIMD_CFUNC simd_char2 simd_bitselect(simd_char2 x, simd_char2 y, simd_char2 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_char3 simd_bitselect(simd_char3 x, simd_char3 y, simd_char3 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_char4 simd_bitselect(simd_char4 x, simd_char4 y, simd_char4 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_char8 simd_bitselect(simd_char8 x, simd_char8 y, simd_char8 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_char16 simd_bitselect(simd_char16 x, simd_char16 y, simd_char16 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_char32 simd_bitselect(simd_char32 x, simd_char32 y, simd_char32 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_char64 simd_bitselect(simd_char64 x, simd_char64 y, simd_char64 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_uchar2 simd_bitselect(simd_uchar2 x, simd_uchar2 y, simd_char2 mask) {
-  return (simd_uchar2)simd_bitselect((simd_char2)x, (simd_char2)y, mask);
-}
-static inline SIMD_CFUNC simd_uchar3 simd_bitselect(simd_uchar3 x, simd_uchar3 y, simd_char3 mask) {
-  return (simd_uchar3)simd_bitselect((simd_char3)x, (simd_char3)y, mask);
-}
-static inline SIMD_CFUNC simd_uchar4 simd_bitselect(simd_uchar4 x, simd_uchar4 y, simd_char4 mask) {
-  return (simd_uchar4)simd_bitselect((simd_char4)x, (simd_char4)y, mask);
-}
-static inline SIMD_CFUNC simd_uchar8 simd_bitselect(simd_uchar8 x, simd_uchar8 y, simd_char8 mask) {
-  return (simd_uchar8)simd_bitselect((simd_char8)x, (simd_char8)y, mask);
-}
-static inline SIMD_CFUNC simd_uchar16 simd_bitselect(simd_uchar16 x, simd_uchar16 y, simd_char16 mask) {
-  return (simd_uchar16)simd_bitselect((simd_char16)x, (simd_char16)y, mask);
-}
-static inline SIMD_CFUNC simd_uchar32 simd_bitselect(simd_uchar32 x, simd_uchar32 y, simd_char32 mask) {
-  return (simd_uchar32)simd_bitselect((simd_char32)x, (simd_char32)y, mask);
-}
-static inline SIMD_CFUNC simd_uchar64 simd_bitselect(simd_uchar64 x, simd_uchar64 y, simd_char64 mask) {
-  return (simd_uchar64)simd_bitselect((simd_char64)x, (simd_char64)y, mask);
-}
-static inline SIMD_CFUNC simd_short2 simd_bitselect(simd_short2 x, simd_short2 y, simd_short2 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_short3 simd_bitselect(simd_short3 x, simd_short3 y, simd_short3 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_short4 simd_bitselect(simd_short4 x, simd_short4 y, simd_short4 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_short8 simd_bitselect(simd_short8 x, simd_short8 y, simd_short8 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_short16 simd_bitselect(simd_short16 x, simd_short16 y, simd_short16 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_short32 simd_bitselect(simd_short32 x, simd_short32 y, simd_short32 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_ushort2 simd_bitselect(simd_ushort2 x, simd_ushort2 y, simd_short2 mask) {
-  return (simd_ushort2)simd_bitselect((simd_short2)x, (simd_short2)y, mask);
-}
-static inline SIMD_CFUNC simd_ushort3 simd_bitselect(simd_ushort3 x, simd_ushort3 y, simd_short3 mask) {
-  return (simd_ushort3)simd_bitselect((simd_short3)x, (simd_short3)y, mask);
-}
-static inline SIMD_CFUNC simd_ushort4 simd_bitselect(simd_ushort4 x, simd_ushort4 y, simd_short4 mask) {
-  return (simd_ushort4)simd_bitselect((simd_short4)x, (simd_short4)y, mask);
-}
-static inline SIMD_CFUNC simd_ushort8 simd_bitselect(simd_ushort8 x, simd_ushort8 y, simd_short8 mask) {
-  return (simd_ushort8)simd_bitselect((simd_short8)x, (simd_short8)y, mask);
-}
-static inline SIMD_CFUNC simd_ushort16 simd_bitselect(simd_ushort16 x, simd_ushort16 y, simd_short16 mask) {
-  return (simd_ushort16)simd_bitselect((simd_short16)x, (simd_short16)y, mask);
-}
-static inline SIMD_CFUNC simd_ushort32 simd_bitselect(simd_ushort32 x, simd_ushort32 y, simd_short32 mask) {
-  return (simd_ushort32)simd_bitselect((simd_short32)x, (simd_short32)y, mask);
-}
-static inline SIMD_CFUNC simd_int2 simd_bitselect(simd_int2 x, simd_int2 y, simd_int2 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_int3 simd_bitselect(simd_int3 x, simd_int3 y, simd_int3 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_int4 simd_bitselect(simd_int4 x, simd_int4 y, simd_int4 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_int8 simd_bitselect(simd_int8 x, simd_int8 y, simd_int8 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_int16 simd_bitselect(simd_int16 x, simd_int16 y, simd_int16 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_uint2 simd_bitselect(simd_uint2 x, simd_uint2 y, simd_int2 mask) {
-  return (simd_uint2)simd_bitselect((simd_int2)x, (simd_int2)y, mask);
-}
-static inline SIMD_CFUNC simd_uint3 simd_bitselect(simd_uint3 x, simd_uint3 y, simd_int3 mask) {
-  return (simd_uint3)simd_bitselect((simd_int3)x, (simd_int3)y, mask);
-}
-static inline SIMD_CFUNC simd_uint4 simd_bitselect(simd_uint4 x, simd_uint4 y, simd_int4 mask) {
-  return (simd_uint4)simd_bitselect((simd_int4)x, (simd_int4)y, mask);
-}
-static inline SIMD_CFUNC simd_uint8 simd_bitselect(simd_uint8 x, simd_uint8 y, simd_int8 mask) {
-  return (simd_uint8)simd_bitselect((simd_int8)x, (simd_int8)y, mask);
-}
-static inline SIMD_CFUNC simd_uint16 simd_bitselect(simd_uint16 x, simd_uint16 y, simd_int16 mask) {
-  return (simd_uint16)simd_bitselect((simd_int16)x, (simd_int16)y, mask);
-}
-static inline SIMD_CFUNC simd_float2 simd_bitselect(simd_float2 x, simd_float2 y, simd_int2 mask) {
-  return (simd_float2)simd_bitselect((simd_int2)x, (simd_int2)y, mask);
-}
-static inline SIMD_CFUNC simd_float3 simd_bitselect(simd_float3 x, simd_float3 y, simd_int3 mask) {
-  return (simd_float3)simd_bitselect((simd_int3)x, (simd_int3)y, mask);
-}
-static inline SIMD_CFUNC simd_float4 simd_bitselect(simd_float4 x, simd_float4 y, simd_int4 mask) {
-  return (simd_float4)simd_bitselect((simd_int4)x, (simd_int4)y, mask);
-}
-static inline SIMD_CFUNC simd_float8 simd_bitselect(simd_float8 x, simd_float8 y, simd_int8 mask) {
-  return (simd_float8)simd_bitselect((simd_int8)x, (simd_int8)y, mask);
-}
-static inline SIMD_CFUNC simd_float16 simd_bitselect(simd_float16 x, simd_float16 y, simd_int16 mask) {
-  return (simd_float16)simd_bitselect((simd_int16)x, (simd_int16)y, mask);
-}
-static inline SIMD_CFUNC simd_long2 simd_bitselect(simd_long2 x, simd_long2 y, simd_long2 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_long3 simd_bitselect(simd_long3 x, simd_long3 y, simd_long3 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_long4 simd_bitselect(simd_long4 x, simd_long4 y, simd_long4 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_long8 simd_bitselect(simd_long8 x, simd_long8 y, simd_long8 mask) {
-  return (x & ~mask) | (y & mask);
-}
-static inline SIMD_CFUNC simd_ulong2 simd_bitselect(simd_ulong2 x, simd_ulong2 y, simd_long2 mask) {
-  return (simd_ulong2)simd_bitselect((simd_long2)x, (simd_long2)y, mask);
-}
-static inline SIMD_CFUNC simd_ulong3 simd_bitselect(simd_ulong3 x, simd_ulong3 y, simd_long3 mask) {
-  return (simd_ulong3)simd_bitselect((simd_long3)x, (simd_long3)y, mask);
-}
-static inline SIMD_CFUNC simd_ulong4 simd_bitselect(simd_ulong4 x, simd_ulong4 y, simd_long4 mask) {
-  return (simd_ulong4)simd_bitselect((simd_long4)x, (simd_long4)y, mask);
-}
-static inline SIMD_CFUNC simd_ulong8 simd_bitselect(simd_ulong8 x, simd_ulong8 y, simd_long8 mask) {
-  return (simd_ulong8)simd_bitselect((simd_long8)x, (simd_long8)y, mask);
-}
-static inline SIMD_CFUNC simd_double2 simd_bitselect(simd_double2 x, simd_double2 y, simd_long2 mask) {
-  return (simd_double2)simd_bitselect((simd_long2)x, (simd_long2)y, mask);
-}
-static inline SIMD_CFUNC simd_double3 simd_bitselect(simd_double3 x, simd_double3 y, simd_long3 mask) {
-  return (simd_double3)simd_bitselect((simd_long3)x, (simd_long3)y, mask);
-}
-static inline SIMD_CFUNC simd_double4 simd_bitselect(simd_double4 x, simd_double4 y, simd_long4 mask) {
-  return (simd_double4)simd_bitselect((simd_long4)x, (simd_long4)y, mask);
-}
-static inline SIMD_CFUNC simd_double8 simd_bitselect(simd_double8 x, simd_double8 y, simd_long8 mask) {
-  return (simd_double8)simd_bitselect((simd_long8)x, (simd_long8)y, mask);
-}
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */
-#endif /* __SIMD_LOGIC_HEADER__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/simd/matrix.h b/lib/libc/include/x86_64-macos.10-none/simd/matrix.h
deleted file mode 100644
index a62384e133..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/simd/matrix.h
+++ /dev/null
@@ -1,1786 +0,0 @@
-/* Copyright (c) 2014-2017 Apple, Inc. All rights reserved.
- *
- *      Function                        Result
- *      ------------------------------------------------------------------
- *
- *      simd_diagonal_matrix(x)         A square matrix with the vector x
- *                                      as its diagonal.
- *
- *      simd_matrix(c0, c1, ... )       A matrix with the specified vectors
- *                                      as columns.
- *
- *      simd_matrix_from_rows(r0, r1, ... )  A matrix with the specified vectors
- *                                      as rows.
- *
- *      simd_mul(a,x)                   Scalar product a*x.
- *
- *      simd_linear_combination(a,x,b,y)  a*x + b*y.
- *
- *      simd_add(x,y)                   Macro wrapping linear_combination
- *                                      to compute x + y.
- *
- *      simd_sub(x,y)                   Macro wrapping linear_combination
- *                                      to compute x - y.
- *
- *      simd_transpose(x)               Transpose of the matrix x.
- *
- *      simd_inverse(x)                 Inverse of x if x is non-singular.  If
- *                                      x is singular, the result is undefined.
- *
- *      simd_mul(x,y)                   If x is a matrix, returns the matrix
- *                                      product x*y, where y is either a matrix
- *                                      or a column vector.  If x is a vector,
- *                                      returns the product x*y where x is
- *                                      interpreted as a row vector.
- *
- *      simd_equal(x,y)                 Returns true if and only if every
- *                                      element of x is exactly equal to the
- *                                      corresponding element of y.
- *
- *      simd_almost_equal_elements(x,y,tol)
- *                                      Returns true if and only if for each
- *                                      entry xij in x, the corresponding
- *                                      element yij in y satisfies
- *                                      |xij - yij| <= tol.
- *
- *      simd_almost_equal_elements_relative(x,y,tol)
- *                                      Returns true if and only if for each
- *                                      entry xij in x, the corresponding
- *                                      element yij in y satisfies
- *                                      |xij - yij| <= tol*|xij|.
- *
- *  The header also defines a few useful global matrix objects:
- *  matrix_identity_floatNxM and matrix_identity_doubleNxM, may be used to get
- *  an identity matrix of the specified size.
- *
- *  In C++, we are able to use namespacing to make the functions more concise;
- *  we also overload some common arithmetic operators to work with the matrix
- *  types:
- *
- *      C++ Function                    Equivalent C Function
- *      --------------------------------------------------------------------
- *      simd::inverse                   simd_inverse
- *      simd::transpose                 simd_transpose
- *      operator+                       simd_add
- *      operator-                       simd_sub
- *      operator+=                      N/A
- *      operator-=                      N/A
- *      operator*                       simd_mul or simd_mul
- *      operator*=                      simd_mul or simd_mul
- *      operator==                      simd_equal
- *      operator!=                      !simd_equal
- *      simd::almost_equal_elements     simd_almost_equal_elements
- *      simd::almost_equal_elements_relative  simd_almost_equal_elements_relative
- *
- *  <simd/matrix_types.h> provides constructors for C++ matrix types.
- */
-
-#ifndef SIMD_MATRIX_HEADER
-#define SIMD_MATRIX_HEADER
-
-#include <simd/base.h>
-#if SIMD_COMPILER_HAS_REQUIRED_FEATURES
-#include <simd/matrix_types.h>
-#include <simd/geometry.h>
-#include <simd/extern.h>
-#include <simd/logic.h>
-
-#ifdef __cplusplus
-    extern "C" {
-#endif
-
-extern const simd_float2x2 matrix_identity_float2x2  __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0));
-extern const simd_float3x3 matrix_identity_float3x3  __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0));
-extern const simd_float4x4 matrix_identity_float4x4  __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0));
-extern const simd_double2x2 matrix_identity_double2x2 __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0));
-extern const simd_double3x3 matrix_identity_double3x3 __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0));
-extern const simd_double4x4 matrix_identity_double4x4 __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0));
-
-static simd_float2x2 SIMD_CFUNC simd_diagonal_matrix(simd_float2 __x);
-static simd_float3x3 SIMD_CFUNC simd_diagonal_matrix(simd_float3 __x);
-static simd_float4x4 SIMD_CFUNC simd_diagonal_matrix(simd_float4 __x);
-static simd_double2x2 SIMD_CFUNC simd_diagonal_matrix(simd_double2 __x);
-static simd_double3x3 SIMD_CFUNC simd_diagonal_matrix(simd_double3 __x);
-static simd_double4x4 SIMD_CFUNC simd_diagonal_matrix(simd_double4 __x);
-#define matrix_from_diagonal simd_diagonal_matrix
-
-static simd_float2x2 SIMD_CFUNC simd_matrix(simd_float2 col0, simd_float2 col1);
-static simd_float3x2 SIMD_CFUNC simd_matrix(simd_float2 col0, simd_float2 col1, simd_float2 col2);
-static simd_float4x2 SIMD_CFUNC simd_matrix(simd_float2 col0, simd_float2 col1, simd_float2 col2, simd_float2 col3);
-static simd_float2x3 SIMD_CFUNC simd_matrix(simd_float3 col0, simd_float3 col1);
-static simd_float3x3 SIMD_CFUNC simd_matrix(simd_float3 col0, simd_float3 col1, simd_float3 col2);
-static simd_float4x3 SIMD_CFUNC simd_matrix(simd_float3 col0, simd_float3 col1, simd_float3 col2, simd_float3 col3);
-static simd_float2x4 SIMD_CFUNC simd_matrix(simd_float4 col0, simd_float4 col1);
-static simd_float3x4 SIMD_CFUNC simd_matrix(simd_float4 col0, simd_float4 col1, simd_float4 col2);
-static simd_float4x4 SIMD_CFUNC simd_matrix(simd_float4 col0, simd_float4 col1, simd_float4 col2, simd_float4 col3);
-static simd_double2x2 SIMD_CFUNC simd_matrix(simd_double2 col0, simd_double2 col1);
-static simd_double3x2 SIMD_CFUNC simd_matrix(simd_double2 col0, simd_double2 col1, simd_double2 col2);
-static simd_double4x2 SIMD_CFUNC simd_matrix(simd_double2 col0, simd_double2 col1, simd_double2 col2, simd_double2 col3);
-static simd_double2x3 SIMD_CFUNC simd_matrix(simd_double3 col0, simd_double3 col1);
-static simd_double3x3 SIMD_CFUNC simd_matrix(simd_double3 col0, simd_double3 col1, simd_double3 col2);
-static simd_double4x3 SIMD_CFUNC simd_matrix(simd_double3 col0, simd_double3 col1, simd_double3 col2, simd_double3 col3);
-static simd_double2x4 SIMD_CFUNC simd_matrix(simd_double4 col0, simd_double4 col1);
-static simd_double3x4 SIMD_CFUNC simd_matrix(simd_double4 col0, simd_double4 col1, simd_double4 col2);
-static simd_double4x4 SIMD_CFUNC simd_matrix(simd_double4 col0, simd_double4 col1, simd_double4 col2, simd_double4 col3);
-#define matrix_from_columns simd_matrix
-
-static simd_float2x2 SIMD_CFUNC simd_matrix_from_rows(simd_float2 row0, simd_float2 row1);
-static simd_float2x3 SIMD_CFUNC simd_matrix_from_rows(simd_float2 row0, simd_float2 row1, simd_float2 row2);
-static simd_float2x4 SIMD_CFUNC simd_matrix_from_rows(simd_float2 row0, simd_float2 row1, simd_float2 row2, simd_float2 row3);
-static simd_float3x2 SIMD_CFUNC simd_matrix_from_rows(simd_float3 row0, simd_float3 row1);
-static simd_float3x3 SIMD_CFUNC simd_matrix_from_rows(simd_float3 row0, simd_float3 row1, simd_float3 row2);
-static simd_float3x4 SIMD_CFUNC simd_matrix_from_rows(simd_float3 row0, simd_float3 row1, simd_float3 row2, simd_float3 row3);
-static simd_float4x2 SIMD_CFUNC simd_matrix_from_rows(simd_float4 row0, simd_float4 row1);
-static simd_float4x3 SIMD_CFUNC simd_matrix_from_rows(simd_float4 row0, simd_float4 row1, simd_float4 row2);
-static simd_float4x4 SIMD_CFUNC simd_matrix_from_rows(simd_float4 row0, simd_float4 row1, simd_float4 row2, simd_float4 row3);
-static simd_double2x2 SIMD_CFUNC simd_matrix_from_rows(simd_double2 row0, simd_double2 row1);
-static simd_double2x3 SIMD_CFUNC simd_matrix_from_rows(simd_double2 row0, simd_double2 row1, simd_double2 row2);
-static simd_double2x4 SIMD_CFUNC simd_matrix_from_rows(simd_double2 row0, simd_double2 row1, simd_double2 row2, simd_double2 row3);
-static simd_double3x2 SIMD_CFUNC simd_matrix_from_rows(simd_double3 row0, simd_double3 row1);
-static simd_double3x3 SIMD_CFUNC simd_matrix_from_rows(simd_double3 row0, simd_double3 row1, simd_double3 row2);
-static simd_double3x4 SIMD_CFUNC simd_matrix_from_rows(simd_double3 row0, simd_double3 row1, simd_double3 row2, simd_double3 row3);
-static simd_double4x2 SIMD_CFUNC simd_matrix_from_rows(simd_double4 row0, simd_double4 row1);
-static simd_double4x3 SIMD_CFUNC simd_matrix_from_rows(simd_double4 row0, simd_double4 row1, simd_double4 row2);
-static simd_double4x4 SIMD_CFUNC simd_matrix_from_rows(simd_double4 row0, simd_double4 row1, simd_double4 row2, simd_double4 row3);
-#define matrix_from_rows simd_matrix_from_rows
-        
-static  simd_float3x3 SIMD_NOINLINE simd_matrix3x3(simd_quatf q);
-static  simd_float4x4 SIMD_NOINLINE simd_matrix4x4(simd_quatf q);
-static simd_double3x3 SIMD_NOINLINE simd_matrix3x3(simd_quatd q);
-static simd_double4x4 SIMD_NOINLINE simd_matrix4x4(simd_quatd q);
-
-static simd_float2x2 SIMD_CFUNC simd_mul(float __a, simd_float2x2 __x);
-static simd_float3x2 SIMD_CFUNC simd_mul(float __a, simd_float3x2 __x);
-static simd_float4x2 SIMD_CFUNC simd_mul(float __a, simd_float4x2 __x);
-static simd_float2x3 SIMD_CFUNC simd_mul(float __a, simd_float2x3 __x);
-static simd_float3x3 SIMD_CFUNC simd_mul(float __a, simd_float3x3 __x);
-static simd_float4x3 SIMD_CFUNC simd_mul(float __a, simd_float4x3 __x);
-static simd_float2x4 SIMD_CFUNC simd_mul(float __a, simd_float2x4 __x);
-static simd_float3x4 SIMD_CFUNC simd_mul(float __a, simd_float3x4 __x);
-static simd_float4x4 SIMD_CFUNC simd_mul(float __a, simd_float4x4 __x);
-static simd_double2x2 SIMD_CFUNC simd_mul(double __a, simd_double2x2 __x);
-static simd_double3x2 SIMD_CFUNC simd_mul(double __a, simd_double3x2 __x);
-static simd_double4x2 SIMD_CFUNC simd_mul(double __a, simd_double4x2 __x);
-static simd_double2x3 SIMD_CFUNC simd_mul(double __a, simd_double2x3 __x);
-static simd_double3x3 SIMD_CFUNC simd_mul(double __a, simd_double3x3 __x);
-static simd_double4x3 SIMD_CFUNC simd_mul(double __a, simd_double4x3 __x);
-static simd_double2x4 SIMD_CFUNC simd_mul(double __a, simd_double2x4 __x);
-static simd_double3x4 SIMD_CFUNC simd_mul(double __a, simd_double3x4 __x);
-static simd_double4x4 SIMD_CFUNC simd_mul(double __a, simd_double4x4 __x);
-
-static simd_float2x2 SIMD_CFUNC simd_linear_combination(float __a, simd_float2x2 __x, float __b, simd_float2x2 __y);
-static simd_float3x2 SIMD_CFUNC simd_linear_combination(float __a, simd_float3x2 __x, float __b, simd_float3x2 __y);
-static simd_float4x2 SIMD_CFUNC simd_linear_combination(float __a, simd_float4x2 __x, float __b, simd_float4x2 __y);
-static simd_float2x3 SIMD_CFUNC simd_linear_combination(float __a, simd_float2x3 __x, float __b, simd_float2x3 __y);
-static simd_float3x3 SIMD_CFUNC simd_linear_combination(float __a, simd_float3x3 __x, float __b, simd_float3x3 __y);
-static simd_float4x3 SIMD_CFUNC simd_linear_combination(float __a, simd_float4x3 __x, float __b, simd_float4x3 __y);
-static simd_float2x4 SIMD_CFUNC simd_linear_combination(float __a, simd_float2x4 __x, float __b, simd_float2x4 __y);
-static simd_float3x4 SIMD_CFUNC simd_linear_combination(float __a, simd_float3x4 __x, float __b, simd_float3x4 __y);
-static simd_float4x4 SIMD_CFUNC simd_linear_combination(float __a, simd_float4x4 __x, float __b, simd_float4x4 __y);
-static simd_double2x2 SIMD_CFUNC simd_linear_combination(double __a, simd_double2x2 __x, double __b, simd_double2x2 __y);
-static simd_double3x2 SIMD_CFUNC simd_linear_combination(double __a, simd_double3x2 __x, double __b, simd_double3x2 __y);
-static simd_double4x2 SIMD_CFUNC simd_linear_combination(double __a, simd_double4x2 __x, double __b, simd_double4x2 __y);
-static simd_double2x3 SIMD_CFUNC simd_linear_combination(double __a, simd_double2x3 __x, double __b, simd_double2x3 __y);
-static simd_double3x3 SIMD_CFUNC simd_linear_combination(double __a, simd_double3x3 __x, double __b, simd_double3x3 __y);
-static simd_double4x3 SIMD_CFUNC simd_linear_combination(double __a, simd_double4x3 __x, double __b, simd_double4x3 __y);
-static simd_double2x4 SIMD_CFUNC simd_linear_combination(double __a, simd_double2x4 __x, double __b, simd_double2x4 __y);
-static simd_double3x4 SIMD_CFUNC simd_linear_combination(double __a, simd_double3x4 __x, double __b, simd_double3x4 __y);
-static simd_double4x4 SIMD_CFUNC simd_linear_combination(double __a, simd_double4x4 __x, double __b, simd_double4x4 __y);
-#define matrix_linear_combination simd_linear_combination
-      
-static simd_float2x2 SIMD_CFUNC simd_add(simd_float2x2 __x, simd_float2x2 __y);
-static simd_float3x2 SIMD_CFUNC simd_add(simd_float3x2 __x, simd_float3x2 __y);
-static simd_float4x2 SIMD_CFUNC simd_add(simd_float4x2 __x, simd_float4x2 __y);
-static simd_float2x3 SIMD_CFUNC simd_add(simd_float2x3 __x, simd_float2x3 __y);
-static simd_float3x3 SIMD_CFUNC simd_add(simd_float3x3 __x, simd_float3x3 __y);
-static simd_float4x3 SIMD_CFUNC simd_add(simd_float4x3 __x, simd_float4x3 __y);
-static simd_float2x4 SIMD_CFUNC simd_add(simd_float2x4 __x, simd_float2x4 __y);
-static simd_float3x4 SIMD_CFUNC simd_add(simd_float3x4 __x, simd_float3x4 __y);
-static simd_float4x4 SIMD_CFUNC simd_add(simd_float4x4 __x, simd_float4x4 __y);
-static simd_double2x2 SIMD_CFUNC simd_add(simd_double2x2 __x, simd_double2x2 __y);
-static simd_double3x2 SIMD_CFUNC simd_add(simd_double3x2 __x, simd_double3x2 __y);
-static simd_double4x2 SIMD_CFUNC simd_add(simd_double4x2 __x, simd_double4x2 __y);
-static simd_double2x3 SIMD_CFUNC simd_add(simd_double2x3 __x, simd_double2x3 __y);
-static simd_double3x3 SIMD_CFUNC simd_add(simd_double3x3 __x, simd_double3x3 __y);
-static simd_double4x3 SIMD_CFUNC simd_add(simd_double4x3 __x, simd_double4x3 __y);
-static simd_double2x4 SIMD_CFUNC simd_add(simd_double2x4 __x, simd_double2x4 __y);
-static simd_double3x4 SIMD_CFUNC simd_add(simd_double3x4 __x, simd_double3x4 __y);
-static simd_double4x4 SIMD_CFUNC simd_add(simd_double4x4 __x, simd_double4x4 __y);
-#define matrix_add simd_add
-      
-static simd_float2x2 SIMD_CFUNC simd_sub(simd_float2x2 __x, simd_float2x2 __y);
-static simd_float3x2 SIMD_CFUNC simd_sub(simd_float3x2 __x, simd_float3x2 __y);
-static simd_float4x2 SIMD_CFUNC simd_sub(simd_float4x2 __x, simd_float4x2 __y);
-static simd_float2x3 SIMD_CFUNC simd_sub(simd_float2x3 __x, simd_float2x3 __y);
-static simd_float3x3 SIMD_CFUNC simd_sub(simd_float3x3 __x, simd_float3x3 __y);
-static simd_float4x3 SIMD_CFUNC simd_sub(simd_float4x3 __x, simd_float4x3 __y);
-static simd_float2x4 SIMD_CFUNC simd_sub(simd_float2x4 __x, simd_float2x4 __y);
-static simd_float3x4 SIMD_CFUNC simd_sub(simd_float3x4 __x, simd_float3x4 __y);
-static simd_float4x4 SIMD_CFUNC simd_sub(simd_float4x4 __x, simd_float4x4 __y);
-static simd_double2x2 SIMD_CFUNC simd_sub(simd_double2x2 __x, simd_double2x2 __y);
-static simd_double3x2 SIMD_CFUNC simd_sub(simd_double3x2 __x, simd_double3x2 __y);
-static simd_double4x2 SIMD_CFUNC simd_sub(simd_double4x2 __x, simd_double4x2 __y);
-static simd_double2x3 SIMD_CFUNC simd_sub(simd_double2x3 __x, simd_double2x3 __y);
-static simd_double3x3 SIMD_CFUNC simd_sub(simd_double3x3 __x, simd_double3x3 __y);
-static simd_double4x3 SIMD_CFUNC simd_sub(simd_double4x3 __x, simd_double4x3 __y);
-static simd_double2x4 SIMD_CFUNC simd_sub(simd_double2x4 __x, simd_double2x4 __y);
-static simd_double3x4 SIMD_CFUNC simd_sub(simd_double3x4 __x, simd_double3x4 __y);
-static simd_double4x4 SIMD_CFUNC simd_sub(simd_double4x4 __x, simd_double4x4 __y);
-#define matrix_sub simd_sub
-
-static simd_float2x2 SIMD_CFUNC simd_transpose(simd_float2x2 __x);
-static simd_float2x3 SIMD_CFUNC simd_transpose(simd_float3x2 __x);
-static simd_float2x4 SIMD_CFUNC simd_transpose(simd_float4x2 __x);
-static simd_float3x2 SIMD_CFUNC simd_transpose(simd_float2x3 __x);
-static simd_float3x3 SIMD_CFUNC simd_transpose(simd_float3x3 __x);
-static simd_float3x4 SIMD_CFUNC simd_transpose(simd_float4x3 __x);
-static simd_float4x2 SIMD_CFUNC simd_transpose(simd_float2x4 __x);
-static simd_float4x3 SIMD_CFUNC simd_transpose(simd_float3x4 __x);
-static simd_float4x4 SIMD_CFUNC simd_transpose(simd_float4x4 __x);
-static simd_double2x2 SIMD_CFUNC simd_transpose(simd_double2x2 __x);
-static simd_double2x3 SIMD_CFUNC simd_transpose(simd_double3x2 __x);
-static simd_double2x4 SIMD_CFUNC simd_transpose(simd_double4x2 __x);
-static simd_double3x2 SIMD_CFUNC simd_transpose(simd_double2x3 __x);
-static simd_double3x3 SIMD_CFUNC simd_transpose(simd_double3x3 __x);
-static simd_double3x4 SIMD_CFUNC simd_transpose(simd_double4x3 __x);
-static simd_double4x2 SIMD_CFUNC simd_transpose(simd_double2x4 __x);
-static simd_double4x3 SIMD_CFUNC simd_transpose(simd_double3x4 __x);
-static simd_double4x4 SIMD_CFUNC simd_transpose(simd_double4x4 __x);
-#define matrix_transpose simd_transpose
-
-static float SIMD_CFUNC simd_determinant(simd_float2x2 __x);
-static float SIMD_CFUNC simd_determinant(simd_float3x3 __x);
-static float SIMD_CFUNC simd_determinant(simd_float4x4 __x);
-static double SIMD_CFUNC simd_determinant(simd_double2x2 __x);
-static double SIMD_CFUNC simd_determinant(simd_double3x3 __x);
-static double SIMD_CFUNC simd_determinant(simd_double4x4 __x);
-#define matrix_determinant simd_determinant
-
-static simd_float2x2 SIMD_CFUNC simd_inverse(simd_float2x2 __x) __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0));
-static simd_float3x3 SIMD_CFUNC simd_inverse(simd_float3x3 __x) __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0));
-static simd_float4x4 SIMD_CFUNC simd_inverse(simd_float4x4 __x) __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0));
-static simd_double2x2 SIMD_CFUNC simd_inverse(simd_double2x2 __x) __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0));
-static simd_double3x3 SIMD_CFUNC simd_inverse(simd_double3x3 __x) __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0));
-static simd_double4x4 SIMD_CFUNC simd_inverse(simd_double4x4 __x) __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0));
-#define matrix_invert simd_inverse
-
-static simd_float2 SIMD_CFUNC simd_mul(simd_float2x2 __x, simd_float2 __y);
-static simd_float2 SIMD_CFUNC simd_mul(simd_float3x2 __x, simd_float3 __y);
-static simd_float2 SIMD_CFUNC simd_mul(simd_float4x2 __x, simd_float4 __y);
-static simd_float3 SIMD_CFUNC simd_mul(simd_float2x3 __x, simd_float2 __y);
-static simd_float3 SIMD_CFUNC simd_mul(simd_float3x3 __x, simd_float3 __y);
-static simd_float3 SIMD_CFUNC simd_mul(simd_float4x3 __x, simd_float4 __y);
-static simd_float4 SIMD_CFUNC simd_mul(simd_float2x4 __x, simd_float2 __y);
-static simd_float4 SIMD_CFUNC simd_mul(simd_float3x4 __x, simd_float3 __y);
-static simd_float4 SIMD_CFUNC simd_mul(simd_float4x4 __x, simd_float4 __y);
-static simd_double2 SIMD_CFUNC simd_mul(simd_double2x2 __x, simd_double2 __y);
-static simd_double2 SIMD_CFUNC simd_mul(simd_double3x2 __x, simd_double3 __y);
-static simd_double2 SIMD_CFUNC simd_mul(simd_double4x2 __x, simd_double4 __y);
-static simd_double3 SIMD_CFUNC simd_mul(simd_double2x3 __x, simd_double2 __y);
-static simd_double3 SIMD_CFUNC simd_mul(simd_double3x3 __x, simd_double3 __y);
-static simd_double3 SIMD_CFUNC simd_mul(simd_double4x3 __x, simd_double4 __y);
-static simd_double4 SIMD_CFUNC simd_mul(simd_double2x4 __x, simd_double2 __y);
-static simd_double4 SIMD_CFUNC simd_mul(simd_double3x4 __x, simd_double3 __y);
-static simd_double4 SIMD_CFUNC simd_mul(simd_double4x4 __x, simd_double4 __y);
-static simd_float2 SIMD_CFUNC simd_mul(simd_float2 __x, simd_float2x2 __y);
-static simd_float3 SIMD_CFUNC simd_mul(simd_float2 __x, simd_float3x2 __y);
-static simd_float4 SIMD_CFUNC simd_mul(simd_float2 __x, simd_float4x2 __y);
-static simd_float2 SIMD_CFUNC simd_mul(simd_float3 __x, simd_float2x3 __y);
-static simd_float3 SIMD_CFUNC simd_mul(simd_float3 __x, simd_float3x3 __y);
-static simd_float4 SIMD_CFUNC simd_mul(simd_float3 __x, simd_float4x3 __y);
-static simd_float2 SIMD_CFUNC simd_mul(simd_float4 __x, simd_float2x4 __y);
-static simd_float3 SIMD_CFUNC simd_mul(simd_float4 __x, simd_float3x4 __y);
-static simd_float4 SIMD_CFUNC simd_mul(simd_float4 __x, simd_float4x4 __y);
-static simd_double2 SIMD_CFUNC simd_mul(simd_double2 __x, simd_double2x2 __y);
-static simd_double3 SIMD_CFUNC simd_mul(simd_double2 __x, simd_double3x2 __y);
-static simd_double4 SIMD_CFUNC simd_mul(simd_double2 __x, simd_double4x2 __y);
-static simd_double2 SIMD_CFUNC simd_mul(simd_double3 __x, simd_double2x3 __y);
-static simd_double3 SIMD_CFUNC simd_mul(simd_double3 __x, simd_double3x3 __y);
-static simd_double4 SIMD_CFUNC simd_mul(simd_double3 __x, simd_double4x3 __y);
-static simd_double2 SIMD_CFUNC simd_mul(simd_double4 __x, simd_double2x4 __y);
-static simd_double3 SIMD_CFUNC simd_mul(simd_double4 __x, simd_double3x4 __y);
-static simd_double4 SIMD_CFUNC simd_mul(simd_double4 __x, simd_double4x4 __y);
-static simd_float2x2 SIMD_CFUNC simd_mul(simd_float2x2 __x, simd_float2x2 __y);
-static simd_float3x2 SIMD_CFUNC simd_mul(simd_float2x2 __x, simd_float3x2 __y);
-static simd_float4x2 SIMD_CFUNC simd_mul(simd_float2x2 __x, simd_float4x2 __y);
-static simd_float2x3 SIMD_CFUNC simd_mul(simd_float2x3 __x, simd_float2x2 __y);
-static simd_float3x3 SIMD_CFUNC simd_mul(simd_float2x3 __x, simd_float3x2 __y);
-static simd_float4x3 SIMD_CFUNC simd_mul(simd_float2x3 __x, simd_float4x2 __y);
-static simd_float2x4 SIMD_CFUNC simd_mul(simd_float2x4 __x, simd_float2x2 __y);
-static simd_float3x4 SIMD_CFUNC simd_mul(simd_float2x4 __x, simd_float3x2 __y);
-static simd_float4x4 SIMD_CFUNC simd_mul(simd_float2x4 __x, simd_float4x2 __y);
-static simd_double2x2 SIMD_CFUNC simd_mul(simd_double2x2 __x, simd_double2x2 __y);
-static simd_double3x2 SIMD_CFUNC simd_mul(simd_double2x2 __x, simd_double3x2 __y);
-static simd_double4x2 SIMD_CFUNC simd_mul(simd_double2x2 __x, simd_double4x2 __y);
-static simd_double2x3 SIMD_CFUNC simd_mul(simd_double2x3 __x, simd_double2x2 __y);
-static simd_double3x3 SIMD_CFUNC simd_mul(simd_double2x3 __x, simd_double3x2 __y);
-static simd_double4x3 SIMD_CFUNC simd_mul(simd_double2x3 __x, simd_double4x2 __y);
-static simd_double2x4 SIMD_CFUNC simd_mul(simd_double2x4 __x, simd_double2x2 __y);
-static simd_double3x4 SIMD_CFUNC simd_mul(simd_double2x4 __x, simd_double3x2 __y);
-static simd_double4x4 SIMD_CFUNC simd_mul(simd_double2x4 __x, simd_double4x2 __y);
-static simd_float2x2 SIMD_CFUNC simd_mul(simd_float3x2 __x, simd_float2x3 __y);
-static simd_float3x2 SIMD_CFUNC simd_mul(simd_float3x2 __x, simd_float3x3 __y);
-static simd_float4x2 SIMD_CFUNC simd_mul(simd_float3x2 __x, simd_float4x3 __y);
-static simd_float2x3 SIMD_CFUNC simd_mul(simd_float3x3 __x, simd_float2x3 __y);
-static simd_float3x3 SIMD_CFUNC simd_mul(simd_float3x3 __x, simd_float3x3 __y);
-static simd_float4x3 SIMD_CFUNC simd_mul(simd_float3x3 __x, simd_float4x3 __y);
-static simd_float2x4 SIMD_CFUNC simd_mul(simd_float3x4 __x, simd_float2x3 __y);
-static simd_float3x4 SIMD_CFUNC simd_mul(simd_float3x4 __x, simd_float3x3 __y);
-static simd_float4x4 SIMD_CFUNC simd_mul(simd_float3x4 __x, simd_float4x3 __y);
-static simd_double2x2 SIMD_CFUNC simd_mul(simd_double3x2 __x, simd_double2x3 __y);
-static simd_double3x2 SIMD_CFUNC simd_mul(simd_double3x2 __x, simd_double3x3 __y);
-static simd_double4x2 SIMD_CFUNC simd_mul(simd_double3x2 __x, simd_double4x3 __y);
-static simd_double2x3 SIMD_CFUNC simd_mul(simd_double3x3 __x, simd_double2x3 __y);
-static simd_double3x3 SIMD_CFUNC simd_mul(simd_double3x3 __x, simd_double3x3 __y);
-static simd_double4x3 SIMD_CFUNC simd_mul(simd_double3x3 __x, simd_double4x3 __y);
-static simd_double2x4 SIMD_CFUNC simd_mul(simd_double3x4 __x, simd_double2x3 __y);
-static simd_double3x4 SIMD_CFUNC simd_mul(simd_double3x4 __x, simd_double3x3 __y);
-static simd_double4x4 SIMD_CFUNC simd_mul(simd_double3x4 __x, simd_double4x3 __y);
-static simd_float2x2 SIMD_CFUNC simd_mul(simd_float4x2 __x, simd_float2x4 __y);
-static simd_float3x2 SIMD_CFUNC simd_mul(simd_float4x2 __x, simd_float3x4 __y);
-static simd_float4x2 SIMD_CFUNC simd_mul(simd_float4x2 __x, simd_float4x4 __y);
-static simd_float2x3 SIMD_CFUNC simd_mul(simd_float4x3 __x, simd_float2x4 __y);
-static simd_float3x3 SIMD_CFUNC simd_mul(simd_float4x3 __x, simd_float3x4 __y);
-static simd_float4x3 SIMD_CFUNC simd_mul(simd_float4x3 __x, simd_float4x4 __y);
-static simd_float2x4 SIMD_CFUNC simd_mul(simd_float4x4 __x, simd_float2x4 __y);
-static simd_float3x4 SIMD_CFUNC simd_mul(simd_float4x4 __x, simd_float3x4 __y);
-static simd_float4x4 SIMD_CFUNC simd_mul(simd_float4x4 __x, simd_float4x4 __y);
-static simd_double2x2 SIMD_CFUNC simd_mul(simd_double4x2 __x, simd_double2x4 __y);
-static simd_double3x2 SIMD_CFUNC simd_mul(simd_double4x2 __x, simd_double3x4 __y);
-static simd_double4x2 SIMD_CFUNC simd_mul(simd_double4x2 __x, simd_double4x4 __y);
-static simd_double2x3 SIMD_CFUNC simd_mul(simd_double4x3 __x, simd_double2x4 __y);
-static simd_double3x3 SIMD_CFUNC simd_mul(simd_double4x3 __x, simd_double3x4 __y);
-static simd_double4x3 SIMD_CFUNC simd_mul(simd_double4x3 __x, simd_double4x4 __y);
-static simd_double2x4 SIMD_CFUNC simd_mul(simd_double4x4 __x, simd_double2x4 __y);
-static simd_double3x4 SIMD_CFUNC simd_mul(simd_double4x4 __x, simd_double3x4 __y);
-static simd_double4x4 SIMD_CFUNC simd_mul(simd_double4x4 __x, simd_double4x4 __y);
-    
-static simd_bool SIMD_CFUNC simd_equal(simd_float2x2 __x, simd_float2x2 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_float2x3 __x, simd_float2x3 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_float2x4 __x, simd_float2x4 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_float3x2 __x, simd_float3x2 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_float3x3 __x, simd_float3x3 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_float3x4 __x, simd_float3x4 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_float4x2 __x, simd_float4x2 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_float4x3 __x, simd_float4x3 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_float4x4 __x, simd_float4x4 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_double2x2 __x, simd_double2x2 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_double2x3 __x, simd_double2x3 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_double2x4 __x, simd_double2x4 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_double3x2 __x, simd_double3x2 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_double3x3 __x, simd_double3x3 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_double3x4 __x, simd_double3x4 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_double4x2 __x, simd_double4x2 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_double4x3 __x, simd_double4x3 __y);
-static simd_bool SIMD_CFUNC simd_equal(simd_double4x4 __x, simd_double4x4 __y);
-#define matrix_equal simd_equal
-      
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float2x2 __x, simd_float2x2 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float2x3 __x, simd_float2x3 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float2x4 __x, simd_float2x4 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float3x2 __x, simd_float3x2 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float3x3 __x, simd_float3x3 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float3x4 __x, simd_float3x4 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float4x2 __x, simd_float4x2 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float4x3 __x, simd_float4x3 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float4x4 __x, simd_float4x4 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double2x2 __x, simd_double2x2 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double2x3 __x, simd_double2x3 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double2x4 __x, simd_double2x4 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double3x2 __x, simd_double3x2 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double3x3 __x, simd_double3x3 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double3x4 __x, simd_double3x4 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double4x2 __x, simd_double4x2 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double4x3 __x, simd_double4x3 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double4x4 __x, simd_double4x4 __y, double __tol);
-#define matrix_almost_equal_elements simd_almost_equal_elements
-      
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float2x2 __x, simd_float2x2 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float2x3 __x, simd_float2x3 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float2x4 __x, simd_float2x4 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float3x2 __x, simd_float3x2 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float3x3 __x, simd_float3x3 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float3x4 __x, simd_float3x4 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float4x2 __x, simd_float4x2 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float4x3 __x, simd_float4x3 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float4x4 __x, simd_float4x4 __y, float __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double2x2 __x, simd_double2x2 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double2x3 __x, simd_double2x3 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double2x4 __x, simd_double2x4 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double3x2 __x, simd_double3x2 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double3x3 __x, simd_double3x3 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double3x4 __x, simd_double3x4 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double4x2 __x, simd_double4x2 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double4x3 __x, simd_double4x3 __y, double __tol);
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double4x4 __x, simd_double4x4 __y, double __tol);
-#define matrix_almost_equal_elements_relative simd_almost_equal_elements_relative
-
-#ifdef __cplusplus
-} /* extern "C" */
-
-namespace simd {
-  static SIMD_CPPFUNC float2x2 operator+(const float2x2 x, const float2x2 y) { return float2x2(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC float2x3 operator+(const float2x3 x, const float2x3 y) { return float2x3(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC float2x4 operator+(const float2x4 x, const float2x4 y) { return float2x4(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC float3x2 operator+(const float3x2 x, const float3x2 y) { return float3x2(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC float3x3 operator+(const float3x3 x, const float3x3 y) { return float3x3(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC float3x4 operator+(const float3x4 x, const float3x4 y) { return float3x4(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC float4x2 operator+(const float4x2 x, const float4x2 y) { return float4x2(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC float4x3 operator+(const float4x3 x, const float4x3 y) { return float4x3(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC float4x4 operator+(const float4x4 x, const float4x4 y) { return float4x4(::simd_linear_combination(1, x, 1, y)); }
-  
-  static SIMD_CPPFUNC float2x2 operator-(const float2x2 x, const float2x2 y) { return float2x2(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC float2x3 operator-(const float2x3 x, const float2x3 y) { return float2x3(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC float2x4 operator-(const float2x4 x, const float2x4 y) { return float2x4(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC float3x2 operator-(const float3x2 x, const float3x2 y) { return float3x2(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC float3x3 operator-(const float3x3 x, const float3x3 y) { return float3x3(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC float3x4 operator-(const float3x4 x, const float3x4 y) { return float3x4(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC float4x2 operator-(const float4x2 x, const float4x2 y) { return float4x2(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC float4x3 operator-(const float4x3 x, const float4x3 y) { return float4x3(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC float4x4 operator-(const float4x4 x, const float4x4 y) { return float4x4(::simd_linear_combination(1, x, -1, y)); }
-  
-  static SIMD_CPPFUNC float2x2& operator+=(float2x2& x, const float2x2 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC float2x3& operator+=(float2x3& x, const float2x3 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC float2x4& operator+=(float2x4& x, const float2x4 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC float3x2& operator+=(float3x2& x, const float3x2 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC float3x3& operator+=(float3x3& x, const float3x3 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC float3x4& operator+=(float3x4& x, const float3x4 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC float4x2& operator+=(float4x2& x, const float4x2 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC float4x3& operator+=(float4x3& x, const float4x3 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC float4x4& operator+=(float4x4& x, const float4x4 y) { x = x + y; return x; }
-  
-  static SIMD_CPPFUNC float2x2& operator-=(float2x2& x, const float2x2 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC float2x3& operator-=(float2x3& x, const float2x3 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC float2x4& operator-=(float2x4& x, const float2x4 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC float3x2& operator-=(float3x2& x, const float3x2 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC float3x3& operator-=(float3x3& x, const float3x3 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC float3x4& operator-=(float3x4& x, const float3x4 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC float4x2& operator-=(float4x2& x, const float4x2 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC float4x3& operator-=(float4x3& x, const float4x3 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC float4x4& operator-=(float4x4& x, const float4x4 y) { x = x - y; return x; }
-  
-  static SIMD_CPPFUNC float2x2 transpose(const float2x2 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC float2x3 transpose(const float3x2 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC float2x4 transpose(const float4x2 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC float3x2 transpose(const float2x3 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC float3x3 transpose(const float3x3 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC float3x4 transpose(const float4x3 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC float4x2 transpose(const float2x4 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC float4x3 transpose(const float3x4 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC float4x4 transpose(const float4x4 x) { return ::simd_transpose(x); }
-  
-  static SIMD_CPPFUNC float determinant(const float2x2 x) { return ::simd_determinant(x); }
-  static SIMD_CPPFUNC float determinant(const float3x3 x) { return ::simd_determinant(x); }
-  static SIMD_CPPFUNC float determinant(const float4x4 x) { return ::simd_determinant(x); }
-  
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wgcc-compat"
-  static SIMD_CPPFUNC float2x2 inverse(const float2x2 x) __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0)) { return ::simd_inverse(x); }
-  static SIMD_CPPFUNC float3x3 inverse(const float3x3 x) __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0)) { return ::simd_inverse(x); }
-  static SIMD_CPPFUNC float4x4 inverse(const float4x4 x) __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0)) { return ::simd_inverse(x); }
-#pragma clang diagnostic pop
-  
-  static SIMD_CPPFUNC float2x2 operator*(const float a, const float2x2 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float2x3 operator*(const float a, const float2x3 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float2x4 operator*(const float a, const float2x4 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float3x2 operator*(const float a, const float3x2 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float3x3 operator*(const float a, const float3x3 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float3x4 operator*(const float a, const float3x4 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float4x2 operator*(const float a, const float4x2 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float4x3 operator*(const float a, const float4x3 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float4x4 operator*(const float a, const float4x4 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float2x2 operator*(const float2x2 x, const float a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float2x3 operator*(const float2x3 x, const float a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float2x4 operator*(const float2x4 x, const float a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float3x2 operator*(const float3x2 x, const float a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float3x3 operator*(const float3x3 x, const float a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float3x4 operator*(const float3x4 x, const float a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float4x2 operator*(const float4x2 x, const float a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float4x3 operator*(const float4x3 x, const float a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float4x4 operator*(const float4x4 x, const float a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC float2x2& operator*=(float2x2& x, const float a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC float2x3& operator*=(float2x3& x, const float a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC float2x4& operator*=(float2x4& x, const float a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC float3x2& operator*=(float3x2& x, const float a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC float3x3& operator*=(float3x3& x, const float a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC float3x4& operator*=(float3x4& x, const float a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC float4x2& operator*=(float4x2& x, const float a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC float4x3& operator*=(float4x3& x, const float a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC float4x4& operator*=(float4x4& x, const float a) { x = ::simd_mul(a, x); return x; }
-  
-  static SIMD_CPPFUNC float2 operator*(const float2 x, const float2x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3 operator*(const float2 x, const float3x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4 operator*(const float2 x, const float4x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2 operator*(const float3 x, const float2x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3 operator*(const float3 x, const float3x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4 operator*(const float3 x, const float4x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2 operator*(const float4 x, const float2x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3 operator*(const float4 x, const float3x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4 operator*(const float4 x, const float4x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2 operator*(const float2x2 x, const float2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2 operator*(const float3x2 x, const float3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2 operator*(const float4x2 x, const float4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3 operator*(const float2x3 x, const float2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3 operator*(const float3x3 x, const float3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3 operator*(const float4x3 x, const float4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4 operator*(const float2x4 x, const float2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4 operator*(const float3x4 x, const float3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4 operator*(const float4x4 x, const float4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2& operator*=(float2& x, const float2x2 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC float3& operator*=(float3& x, const float3x3 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC float4& operator*=(float4& x, const float4x4 y) { x = ::simd_mul(x, y); return x; }
-  
-  static SIMD_CPPFUNC float2x2 operator*(const float2x2 x, const float2x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3x2 operator*(const float2x2 x, const float3x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4x2 operator*(const float2x2 x, const float4x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2x3 operator*(const float2x3 x, const float2x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3x3 operator*(const float2x3 x, const float3x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4x3 operator*(const float2x3 x, const float4x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2x4 operator*(const float2x4 x, const float2x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3x4 operator*(const float2x4 x, const float3x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4x4 operator*(const float2x4 x, const float4x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2x2 operator*(const float3x2 x, const float2x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3x2 operator*(const float3x2 x, const float3x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4x2 operator*(const float3x2 x, const float4x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2x3 operator*(const float3x3 x, const float2x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3x3 operator*(const float3x3 x, const float3x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4x3 operator*(const float3x3 x, const float4x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2x4 operator*(const float3x4 x, const float2x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3x4 operator*(const float3x4 x, const float3x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4x4 operator*(const float3x4 x, const float4x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2x2 operator*(const float4x2 x, const float2x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3x2 operator*(const float4x2 x, const float3x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4x2 operator*(const float4x2 x, const float4x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2x3 operator*(const float4x3 x, const float2x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3x3 operator*(const float4x3 x, const float3x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4x3 operator*(const float4x3 x, const float4x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2x4 operator*(const float4x4 x, const float2x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float3x4 operator*(const float4x4 x, const float3x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float4x4 operator*(const float4x4 x, const float4x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC float2x2& operator*=(float2x2& x, const float2x2 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC float2x3& operator*=(float2x3& x, const float2x2 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC float2x4& operator*=(float2x4& x, const float2x2 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC float3x2& operator*=(float3x2& x, const float3x3 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC float3x3& operator*=(float3x3& x, const float3x3 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC float3x4& operator*=(float3x4& x, const float3x3 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC float4x2& operator*=(float4x2& x, const float4x4 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC float4x3& operator*=(float4x3& x, const float4x4 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC float4x4& operator*=(float4x4& x, const float4x4 y) { x = ::simd_mul(x, y); return x; }
-  
-  static SIMD_CPPFUNC bool operator==(const float2x2& x, const float2x2& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const float2x3& x, const float2x3& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const float2x4& x, const float2x4& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const float3x2& x, const float3x2& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const float3x3& x, const float3x3& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const float3x4& x, const float3x4& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const float4x2& x, const float4x2& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const float4x3& x, const float4x3& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const float4x4& x, const float4x4& y) { return ::simd_equal(x, y); }
-  
-  static SIMD_CPPFUNC bool operator!=(const float2x2& x, const float2x2& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const float2x3& x, const float2x3& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const float2x4& x, const float2x4& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const float3x2& x, const float3x2& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const float3x3& x, const float3x3& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const float3x4& x, const float3x4& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const float4x2& x, const float4x2& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const float4x3& x, const float4x3& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const float4x4& x, const float4x4& y) { return !(x == y); }
-  
-  static SIMD_CPPFUNC bool almost_equal_elements(const float2x2 x, const float2x2 y, const float tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const float2x3 x, const float2x3 y, const float tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const float2x4 x, const float2x4 y, const float tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const float3x2 x, const float3x2 y, const float tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const float3x3 x, const float3x3 y, const float tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const float3x4 x, const float3x4 y, const float tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const float4x2 x, const float4x2 y, const float tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const float4x3 x, const float4x3 y, const float tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const float4x4 x, const float4x4 y, const float tol) { return ::simd_almost_equal_elements(x, y, tol); }
-    
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const float2x2 x, const float2x2 y, const float tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const float2x3 x, const float2x3 y, const float tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const float2x4 x, const float2x4 y, const float tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const float3x2 x, const float3x2 y, const float tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const float3x3 x, const float3x3 y, const float tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const float3x4 x, const float3x4 y, const float tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const float4x2 x, const float4x2 y, const float tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const float4x3 x, const float4x3 y, const float tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const float4x4 x, const float4x4 y, const float tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  
-  static SIMD_CPPFUNC double2x2 operator+(const double2x2 x, const double2x2 y) { return double2x2(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC double2x3 operator+(const double2x3 x, const double2x3 y) { return double2x3(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC double2x4 operator+(const double2x4 x, const double2x4 y) { return double2x4(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC double3x2 operator+(const double3x2 x, const double3x2 y) { return double3x2(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC double3x3 operator+(const double3x3 x, const double3x3 y) { return double3x3(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC double3x4 operator+(const double3x4 x, const double3x4 y) { return double3x4(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC double4x2 operator+(const double4x2 x, const double4x2 y) { return double4x2(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC double4x3 operator+(const double4x3 x, const double4x3 y) { return double4x3(::simd_linear_combination(1, x, 1, y)); }
-  static SIMD_CPPFUNC double4x4 operator+(const double4x4 x, const double4x4 y) { return double4x4(::simd_linear_combination(1, x, 1, y)); }
-  
-  static SIMD_CPPFUNC double2x2 operator-(const double2x2 x, const double2x2 y) { return double2x2(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC double2x3 operator-(const double2x3 x, const double2x3 y) { return double2x3(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC double2x4 operator-(const double2x4 x, const double2x4 y) { return double2x4(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC double3x2 operator-(const double3x2 x, const double3x2 y) { return double3x2(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC double3x3 operator-(const double3x3 x, const double3x3 y) { return double3x3(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC double3x4 operator-(const double3x4 x, const double3x4 y) { return double3x4(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC double4x2 operator-(const double4x2 x, const double4x2 y) { return double4x2(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC double4x3 operator-(const double4x3 x, const double4x3 y) { return double4x3(::simd_linear_combination(1, x, -1, y)); }
-  static SIMD_CPPFUNC double4x4 operator-(const double4x4 x, const double4x4 y) { return double4x4(::simd_linear_combination(1, x, -1, y)); }
-  
-  static SIMD_CPPFUNC double2x2& operator+=(double2x2& x, const double2x2 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC double2x3& operator+=(double2x3& x, const double2x3 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC double2x4& operator+=(double2x4& x, const double2x4 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC double3x2& operator+=(double3x2& x, const double3x2 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC double3x3& operator+=(double3x3& x, const double3x3 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC double3x4& operator+=(double3x4& x, const double3x4 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC double4x2& operator+=(double4x2& x, const double4x2 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC double4x3& operator+=(double4x3& x, const double4x3 y) { x = x + y; return x; }
-  static SIMD_CPPFUNC double4x4& operator+=(double4x4& x, const double4x4 y) { x = x + y; return x; }
-  
-  static SIMD_CPPFUNC double2x2& operator-=(double2x2& x, const double2x2 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC double2x3& operator-=(double2x3& x, const double2x3 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC double2x4& operator-=(double2x4& x, const double2x4 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC double3x2& operator-=(double3x2& x, const double3x2 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC double3x3& operator-=(double3x3& x, const double3x3 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC double3x4& operator-=(double3x4& x, const double3x4 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC double4x2& operator-=(double4x2& x, const double4x2 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC double4x3& operator-=(double4x3& x, const double4x3 y) { x = x - y; return x; }
-  static SIMD_CPPFUNC double4x4& operator-=(double4x4& x, const double4x4 y) { x = x - y; return x; }
-  
-  static SIMD_CPPFUNC double2x2 transpose(const double2x2 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC double2x3 transpose(const double3x2 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC double2x4 transpose(const double4x2 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC double3x2 transpose(const double2x3 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC double3x3 transpose(const double3x3 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC double3x4 transpose(const double4x3 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC double4x2 transpose(const double2x4 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC double4x3 transpose(const double3x4 x) { return ::simd_transpose(x); }
-  static SIMD_CPPFUNC double4x4 transpose(const double4x4 x) { return ::simd_transpose(x); }
-  
-  static SIMD_CPPFUNC double determinant(const double2x2 x) { return ::simd_determinant(x); }
-  static SIMD_CPPFUNC double determinant(const double3x3 x) { return ::simd_determinant(x); }
-  static SIMD_CPPFUNC double determinant(const double4x4 x) { return ::simd_determinant(x); }
-  
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wgcc-compat"
-  static SIMD_CPPFUNC double2x2 inverse(const double2x2 x) __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0)) { return ::simd_inverse(x); }
-  static SIMD_CPPFUNC double3x3 inverse(const double3x3 x) __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0)) { return ::simd_inverse(x); }
-  static SIMD_CPPFUNC double4x4 inverse(const double4x4 x) __API_AVAILABLE(macos(10.10), ios(8.0), watchos(2.0), tvos(9.0)) { return ::simd_inverse(x); }
-#pragma clang diagnostic pop
-  
-  static SIMD_CPPFUNC double2x2 operator*(const double a, const double2x2 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double2x3 operator*(const double a, const double2x3 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double2x4 operator*(const double a, const double2x4 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double3x2 operator*(const double a, const double3x2 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double3x3 operator*(const double a, const double3x3 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double3x4 operator*(const double a, const double3x4 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double4x2 operator*(const double a, const double4x2 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double4x3 operator*(const double a, const double4x3 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double4x4 operator*(const double a, const double4x4 x) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double2x2 operator*(const double2x2 x, const double a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double2x3 operator*(const double2x3 x, const double a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double2x4 operator*(const double2x4 x, const double a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double3x2 operator*(const double3x2 x, const double a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double3x3 operator*(const double3x3 x, const double a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double3x4 operator*(const double3x4 x, const double a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double4x2 operator*(const double4x2 x, const double a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double4x3 operator*(const double4x3 x, const double a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double4x4 operator*(const double4x4 x, const double a) { return ::simd_mul(a, x); }
-  static SIMD_CPPFUNC double2x2& operator*=(double2x2& x, const double a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC double2x3& operator*=(double2x3& x, const double a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC double2x4& operator*=(double2x4& x, const double a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC double3x2& operator*=(double3x2& x, const double a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC double3x3& operator*=(double3x3& x, const double a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC double3x4& operator*=(double3x4& x, const double a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC double4x2& operator*=(double4x2& x, const double a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC double4x3& operator*=(double4x3& x, const double a) { x = ::simd_mul(a, x); return x; }
-  static SIMD_CPPFUNC double4x4& operator*=(double4x4& x, const double a) { x = ::simd_mul(a, x); return x; }
-  
-  static SIMD_CPPFUNC double2 operator*(const double2 x, const double2x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3 operator*(const double2 x, const double3x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4 operator*(const double2 x, const double4x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2 operator*(const double3 x, const double2x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3 operator*(const double3 x, const double3x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4 operator*(const double3 x, const double4x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2 operator*(const double4 x, const double2x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3 operator*(const double4 x, const double3x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4 operator*(const double4 x, const double4x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2 operator*(const double2x2 x, const double2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2 operator*(const double3x2 x, const double3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2 operator*(const double4x2 x, const double4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3 operator*(const double2x3 x, const double2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3 operator*(const double3x3 x, const double3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3 operator*(const double4x3 x, const double4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4 operator*(const double2x4 x, const double2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4 operator*(const double3x4 x, const double3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4 operator*(const double4x4 x, const double4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2& operator*=(double2& x, const double2x2 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC double3& operator*=(double3& x, const double3x3 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC double4& operator*=(double4& x, const double4x4 y) { x = ::simd_mul(x, y); return x; }
-  
-  static SIMD_CPPFUNC double2x2 operator*(const double2x2 x, const double2x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3x2 operator*(const double2x2 x, const double3x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4x2 operator*(const double2x2 x, const double4x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2x3 operator*(const double2x3 x, const double2x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3x3 operator*(const double2x3 x, const double3x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4x3 operator*(const double2x3 x, const double4x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2x4 operator*(const double2x4 x, const double2x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3x4 operator*(const double2x4 x, const double3x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4x4 operator*(const double2x4 x, const double4x2 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2x2 operator*(const double3x2 x, const double2x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3x2 operator*(const double3x2 x, const double3x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4x2 operator*(const double3x2 x, const double4x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2x3 operator*(const double3x3 x, const double2x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3x3 operator*(const double3x3 x, const double3x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4x3 operator*(const double3x3 x, const double4x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2x4 operator*(const double3x4 x, const double2x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3x4 operator*(const double3x4 x, const double3x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4x4 operator*(const double3x4 x, const double4x3 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2x2 operator*(const double4x2 x, const double2x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3x2 operator*(const double4x2 x, const double3x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4x2 operator*(const double4x2 x, const double4x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2x3 operator*(const double4x3 x, const double2x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3x3 operator*(const double4x3 x, const double3x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4x3 operator*(const double4x3 x, const double4x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2x4 operator*(const double4x4 x, const double2x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double3x4 operator*(const double4x4 x, const double3x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double4x4 operator*(const double4x4 x, const double4x4 y) { return ::simd_mul(x, y); }
-  static SIMD_CPPFUNC double2x2& operator*=(double2x2& x, const double2x2 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC double2x3& operator*=(double2x3& x, const double2x2 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC double2x4& operator*=(double2x4& x, const double2x2 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC double3x2& operator*=(double3x2& x, const double3x3 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC double3x3& operator*=(double3x3& x, const double3x3 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC double3x4& operator*=(double3x4& x, const double3x3 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC double4x2& operator*=(double4x2& x, const double4x4 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC double4x3& operator*=(double4x3& x, const double4x4 y) { x = ::simd_mul(x, y); return x; }
-  static SIMD_CPPFUNC double4x4& operator*=(double4x4& x, const double4x4 y) { x = ::simd_mul(x, y); return x; }
-  
-  static SIMD_CPPFUNC bool operator==(const double2x2& x, const double2x2& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const double2x3& x, const double2x3& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const double2x4& x, const double2x4& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const double3x2& x, const double3x2& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const double3x3& x, const double3x3& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const double3x4& x, const double3x4& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const double4x2& x, const double4x2& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const double4x3& x, const double4x3& y) { return ::simd_equal(x, y); }
-  static SIMD_CPPFUNC bool operator==(const double4x4& x, const double4x4& y) { return ::simd_equal(x, y); }
-  
-  static SIMD_CPPFUNC bool operator!=(const double2x2& x, const double2x2& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const double2x3& x, const double2x3& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const double2x4& x, const double2x4& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const double3x2& x, const double3x2& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const double3x3& x, const double3x3& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const double3x4& x, const double3x4& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const double4x2& x, const double4x2& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const double4x3& x, const double4x3& y) { return !(x == y); }
-  static SIMD_CPPFUNC bool operator!=(const double4x4& x, const double4x4& y) { return !(x == y); }
-  
-  static SIMD_CPPFUNC bool almost_equal_elements(const double2x2 x, const double2x2 y, const double tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const double2x3 x, const double2x3 y, const double tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const double2x4 x, const double2x4 y, const double tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const double3x2 x, const double3x2 y, const double tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const double3x3 x, const double3x3 y, const double tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const double3x4 x, const double3x4 y, const double tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const double4x2 x, const double4x2 y, const double tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const double4x3 x, const double4x3 y, const double tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements(const double4x4 x, const double4x4 y, const double tol) { return ::simd_almost_equal_elements(x, y, tol); }
-  
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const double2x2 x, const double2x2 y, const double tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const double2x3 x, const double2x3 y, const double tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const double2x4 x, const double2x4 y, const double tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const double3x2 x, const double3x2 y, const double tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const double3x3 x, const double3x3 y, const double tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const double3x4 x, const double3x4 y, const double tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const double4x2 x, const double4x2 y, const double tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const double4x3 x, const double4x3 y, const double tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-  static SIMD_CPPFUNC bool almost_equal_elements_relative(const double4x4 x, const double4x4 y, const double tol) { return ::simd_almost_equal_elements_relative(x, y, tol); }
-}
-
-extern "C" {
-#endif /* __cplusplus */
-
-#pragma mark - Implementation
-
-static  simd_float2x2 SIMD_CFUNC simd_diagonal_matrix(simd_float2  __x) {  simd_float2x2 __r = { .columns[0] = {__x.x,0}, .columns[1] = {0,__x.y} }; return __r; }
-static simd_double2x2 SIMD_CFUNC simd_diagonal_matrix(simd_double2 __x) { simd_double2x2 __r = { .columns[0] = {__x.x,0}, .columns[1] = {0,__x.y} }; return __r; }
-static  simd_float3x3 SIMD_CFUNC simd_diagonal_matrix(simd_float3  __x) {  simd_float3x3 __r = { .columns[0] = {__x.x,0,0}, .columns[1] = {0,__x.y,0}, .columns[2] = {0,0,__x.z} }; return __r; }
-static simd_double3x3 SIMD_CFUNC simd_diagonal_matrix(simd_double3 __x) { simd_double3x3 __r = { .columns[0] = {__x.x,0,0}, .columns[1] = {0,__x.y,0}, .columns[2] = {0,0,__x.z} }; return __r; }
-static  simd_float4x4 SIMD_CFUNC simd_diagonal_matrix(simd_float4  __x) {  simd_float4x4 __r = { .columns[0] = {__x.x,0,0,0}, .columns[1] = {0,__x.y,0,0}, .columns[2] = {0,0,__x.z,0}, .columns[3] = {0,0,0,__x.w} }; return __r; }
-static simd_double4x4 SIMD_CFUNC simd_diagonal_matrix(simd_double4 __x) { simd_double4x4 __r = { .columns[0] = {__x.x,0,0,0}, .columns[1] = {0,__x.y,0,0}, .columns[2] = {0,0,__x.z,0}, .columns[3] = {0,0,0,__x.w} }; return __r; }
-
-static  simd_float2x2 SIMD_CFUNC simd_matrix(simd_float2  col0, simd_float2  col1) {  simd_float2x2 __r = { .columns[0] = col0, .columns[1] = col1 }; return __r; }
-static  simd_float2x3 SIMD_CFUNC simd_matrix(simd_float3  col0, simd_float3  col1) {  simd_float2x3 __r = { .columns[0] = col0, .columns[1] = col1 }; return __r; }
-static  simd_float2x4 SIMD_CFUNC simd_matrix(simd_float4  col0, simd_float4  col1) {  simd_float2x4 __r = { .columns[0] = col0, .columns[1] = col1 }; return __r; }
-static simd_double2x2 SIMD_CFUNC simd_matrix(simd_double2 col0, simd_double2 col1) { simd_double2x2 __r = { .columns[0] = col0, .columns[1] = col1 }; return __r; }
-static simd_double2x3 SIMD_CFUNC simd_matrix(simd_double3 col0, simd_double3 col1) { simd_double2x3 __r = { .columns[0] = col0, .columns[1] = col1 }; return __r; }
-static simd_double2x4 SIMD_CFUNC simd_matrix(simd_double4 col0, simd_double4 col1) { simd_double2x4 __r = { .columns[0] = col0, .columns[1] = col1 }; return __r; }
-static  simd_float3x2 SIMD_CFUNC simd_matrix(simd_float2  col0, simd_float2  col1, simd_float2  col2) {  simd_float3x2 __r = { .columns[0] = col0, .columns[1] = col1, .columns[2] = col2 }; return __r; }
-static  simd_float3x3 SIMD_CFUNC simd_matrix(simd_float3  col0, simd_float3  col1, simd_float3  col2) {  simd_float3x3 __r = { .columns[0] = col0, .columns[1] = col1, .columns[2] = col2 }; return __r; }
-static  simd_float3x4 SIMD_CFUNC simd_matrix(simd_float4  col0, simd_float4  col1, simd_float4  col2) {  simd_float3x4 __r = { .columns[0] = col0, .columns[1] = col1, .columns[2] = col2 }; return __r; }
-static simd_double3x2 SIMD_CFUNC simd_matrix(simd_double2 col0, simd_double2 col1, simd_double2 col2) { simd_double3x2 __r = { .columns[0] = col0, .columns[1] = col1, .columns[2] = col2 }; return __r; }
-static simd_double3x3 SIMD_CFUNC simd_matrix(simd_double3 col0, simd_double3 col1, simd_double3 col2) { simd_double3x3 __r = { .columns[0] = col0, .columns[1] = col1, .columns[2] = col2 }; return __r; }
-static simd_double3x4 SIMD_CFUNC simd_matrix(simd_double4 col0, simd_double4 col1, simd_double4 col2) { simd_double3x4 __r = { .columns[0] = col0, .columns[1] = col1, .columns[2] = col2 }; return __r; }
-static  simd_float4x2 SIMD_CFUNC simd_matrix(simd_float2  col0, simd_float2  col1, simd_float2  col2, simd_float2  col3) {  simd_float4x2 __r = { .columns[0] = col0, .columns[1] = col1, .columns[2] = col2, .columns[3] = col3 }; return __r; }
-static  simd_float4x3 SIMD_CFUNC simd_matrix(simd_float3  col0, simd_float3  col1, simd_float3  col2, simd_float3  col3) {  simd_float4x3 __r = { .columns[0] = col0, .columns[1] = col1, .columns[2] = col2, .columns[3] = col3 }; return __r; }
-static  simd_float4x4 SIMD_CFUNC simd_matrix(simd_float4  col0, simd_float4  col1, simd_float4  col2, simd_float4  col3) {  simd_float4x4 __r = { .columns[0] = col0, .columns[1] = col1, .columns[2] = col2, .columns[3] = col3 }; return __r; }
-static simd_double4x2 SIMD_CFUNC simd_matrix(simd_double2 col0, simd_double2 col1, simd_double2 col2, simd_double2 col3) { simd_double4x2 __r = { .columns[0] = col0, .columns[1] = col1, .columns[2] = col2, .columns[3] = col3 }; return __r; }
-static simd_double4x3 SIMD_CFUNC simd_matrix(simd_double3 col0, simd_double3 col1, simd_double3 col2, simd_double3 col3) { simd_double4x3 __r = { .columns[0] = col0, .columns[1] = col1, .columns[2] = col2, .columns[3] = col3 }; return __r; }
-static simd_double4x4 SIMD_CFUNC simd_matrix(simd_double4 col0, simd_double4 col1, simd_double4 col2, simd_double4 col3) { simd_double4x4 __r = { .columns[0] = col0, .columns[1] = col1, .columns[2] = col2, .columns[3] = col3 }; return __r; }
-
-static  simd_float2x2 SIMD_CFUNC simd_matrix_from_rows(simd_float2  row0, simd_float2  row1) { return simd_transpose(simd_matrix(row0, row1)); }
-static  simd_float3x2 SIMD_CFUNC simd_matrix_from_rows(simd_float3  row0, simd_float3  row1) { return simd_transpose(simd_matrix(row0, row1)); }
-static  simd_float4x2 SIMD_CFUNC simd_matrix_from_rows(simd_float4  row0, simd_float4  row1) { return simd_transpose(simd_matrix(row0, row1)); }
-static simd_double2x2 SIMD_CFUNC simd_matrix_from_rows(simd_double2 row0, simd_double2 row1) { return simd_transpose(simd_matrix(row0, row1)); }
-static simd_double3x2 SIMD_CFUNC simd_matrix_from_rows(simd_double3 row0, simd_double3 row1) { return simd_transpose(simd_matrix(row0, row1)); }
-static simd_double4x2 SIMD_CFUNC simd_matrix_from_rows(simd_double4 row0, simd_double4 row1) { return simd_transpose(simd_matrix(row0, row1)); }
-static  simd_float2x3 SIMD_CFUNC simd_matrix_from_rows(simd_float2  row0, simd_float2  row1, simd_float2  row2) { return simd_transpose(simd_matrix(row0, row1, row2)); }
-static  simd_float3x3 SIMD_CFUNC simd_matrix_from_rows(simd_float3  row0, simd_float3  row1, simd_float3  row2) { return simd_transpose(simd_matrix(row0, row1, row2)); }
-static  simd_float4x3 SIMD_CFUNC simd_matrix_from_rows(simd_float4  row0, simd_float4  row1, simd_float4  row2) { return simd_transpose(simd_matrix(row0, row1, row2)); }
-static simd_double2x3 SIMD_CFUNC simd_matrix_from_rows(simd_double2 row0, simd_double2 row1, simd_double2 row2) { return simd_transpose(simd_matrix(row0, row1, row2)); }
-static simd_double3x3 SIMD_CFUNC simd_matrix_from_rows(simd_double3 row0, simd_double3 row1, simd_double3 row2) { return simd_transpose(simd_matrix(row0, row1, row2)); }
-static simd_double4x3 SIMD_CFUNC simd_matrix_from_rows(simd_double4 row0, simd_double4 row1, simd_double4 row2) { return simd_transpose(simd_matrix(row0, row1, row2)); }
-static  simd_float2x4 SIMD_CFUNC simd_matrix_from_rows(simd_float2  row0, simd_float2  row1, simd_float2  row2, simd_float2  row3) { return simd_transpose(simd_matrix(row0, row1, row2, row3)); }
-static  simd_float3x4 SIMD_CFUNC simd_matrix_from_rows(simd_float3  row0, simd_float3  row1, simd_float3  row2, simd_float3  row3) { return simd_transpose(simd_matrix(row0, row1, row2, row3)); }
-static  simd_float4x4 SIMD_CFUNC simd_matrix_from_rows(simd_float4  row0, simd_float4  row1, simd_float4  row2, simd_float4  row3) { return simd_transpose(simd_matrix(row0, row1, row2, row3)); }
-static simd_double2x4 SIMD_CFUNC simd_matrix_from_rows(simd_double2 row0, simd_double2 row1, simd_double2 row2, simd_double2 row3) { return simd_transpose(simd_matrix(row0, row1, row2, row3)); }
-static simd_double3x4 SIMD_CFUNC simd_matrix_from_rows(simd_double3 row0, simd_double3 row1, simd_double3 row2, simd_double3 row3) { return simd_transpose(simd_matrix(row0, row1, row2, row3)); }
-static simd_double4x4 SIMD_CFUNC simd_matrix_from_rows(simd_double4 row0, simd_double4 row1, simd_double4 row2, simd_double4 row3) { return simd_transpose(simd_matrix(row0, row1, row2, row3)); }
-  
-static  simd_float3x3 SIMD_NOINLINE simd_matrix3x3(simd_quatf q) {
-  simd_float4x4 r = simd_matrix4x4(q);
-  return (simd_float3x3){ r.columns[0].xyz, r.columns[1].xyz, r.columns[2].xyz };
-}
-
-static  simd_float4x4 SIMD_NOINLINE simd_matrix4x4(simd_quatf q) {
-  simd_float4 v = q.vector;
-  simd_float4x4 r = {
-    .columns[0] = { 1 - 2*(v.y*v.y + v.z*v.z),
-                        2*(v.x*v.y + v.z*v.w),
-                        2*(v.x*v.z - v.y*v.w), 0 },
-    .columns[1] = {     2*(v.x*v.y - v.z*v.w),
-                    1 - 2*(v.z*v.z + v.x*v.x),
-                        2*(v.y*v.z + v.x*v.w), 0 },
-    .columns[2] = {     2*(v.z*v.x + v.y*v.w),
-                        2*(v.y*v.z - v.x*v.w),
-                    1 - 2*(v.y*v.y + v.x*v.x), 0 },
-    .columns[3] = { 0, 0, 0, 1 }
-  };
-  return r;
-}
-  
-static simd_double3x3 SIMD_NOINLINE simd_matrix3x3(simd_quatd q) {
-  simd_double4x4 r = simd_matrix4x4(q);
-  return (simd_double3x3){ r.columns[0].xyz, r.columns[1].xyz, r.columns[2].xyz };
-}
-
-static simd_double4x4 SIMD_NOINLINE simd_matrix4x4(simd_quatd q) {
-  simd_double4 v = q.vector;
-  simd_double4x4 r = {
-    .columns[0] = { 1 - 2*(v.y*v.y + v.z*v.z),
-                        2*(v.x*v.y + v.z*v.w),
-                        2*(v.x*v.z - v.y*v.w), 0 },
-    .columns[1] = {     2*(v.x*v.y - v.z*v.w),
-                    1 - 2*(v.z*v.z + v.x*v.x),
-                        2*(v.y*v.z + v.x*v.w), 0 },
-    .columns[2] = {     2*(v.z*v.x + v.y*v.w),
-                        2*(v.y*v.z - v.x*v.w),
-                    1 - 2*(v.y*v.y + v.x*v.x), 0 },
-    .columns[3] = { 0, 0, 0, 1 }
-  };
-  return r;
-}
-
-static  simd_float2x2 SIMD_CFUNC matrix_scale(float  __a,  simd_float2x2 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; return __x; }
-static  simd_float3x2 SIMD_CFUNC matrix_scale(float  __a,  simd_float3x2 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; return __x; }
-static  simd_float4x2 SIMD_CFUNC matrix_scale(float  __a,  simd_float4x2 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; __x.columns[3] *= __a; return __x; }
-static  simd_float2x3 SIMD_CFUNC matrix_scale(float  __a,  simd_float2x3 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; return __x; }
-static  simd_float3x3 SIMD_CFUNC matrix_scale(float  __a,  simd_float3x3 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; return __x; }
-static  simd_float4x3 SIMD_CFUNC matrix_scale(float  __a,  simd_float4x3 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; __x.columns[3] *= __a; return __x; }
-static  simd_float2x4 SIMD_CFUNC matrix_scale(float  __a,  simd_float2x4 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; return __x; }
-static  simd_float3x4 SIMD_CFUNC matrix_scale(float  __a,  simd_float3x4 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; return __x; }
-static  simd_float4x4 SIMD_CFUNC matrix_scale(float  __a,  simd_float4x4 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; __x.columns[3] *= __a; return __x; }
-static simd_double2x2 SIMD_CFUNC matrix_scale(double __a, simd_double2x2 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; return __x; }
-static simd_double3x2 SIMD_CFUNC matrix_scale(double __a, simd_double3x2 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; return __x; }
-static simd_double4x2 SIMD_CFUNC matrix_scale(double __a, simd_double4x2 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; __x.columns[3] *= __a; return __x; }
-static simd_double2x3 SIMD_CFUNC matrix_scale(double __a, simd_double2x3 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; return __x; }
-static simd_double3x3 SIMD_CFUNC matrix_scale(double __a, simd_double3x3 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; return __x; }
-static simd_double4x3 SIMD_CFUNC matrix_scale(double __a, simd_double4x3 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; __x.columns[3] *= __a; return __x; }
-static simd_double2x4 SIMD_CFUNC matrix_scale(double __a, simd_double2x4 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; return __x; }
-static simd_double3x4 SIMD_CFUNC matrix_scale(double __a, simd_double3x4 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; return __x; }
-static simd_double4x4 SIMD_CFUNC matrix_scale(double __a, simd_double4x4 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; __x.columns[3] *= __a; return __x; }
-  
-static  simd_float2x2 SIMD_CFUNC simd_mul(float  __a,  simd_float2x2 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; return __x; }
-static  simd_float3x2 SIMD_CFUNC simd_mul(float  __a,  simd_float3x2 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; return __x; }
-static  simd_float4x2 SIMD_CFUNC simd_mul(float  __a,  simd_float4x2 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; __x.columns[3] *= __a; return __x; }
-static  simd_float2x3 SIMD_CFUNC simd_mul(float  __a,  simd_float2x3 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; return __x; }
-static  simd_float3x3 SIMD_CFUNC simd_mul(float  __a,  simd_float3x3 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; return __x; }
-static  simd_float4x3 SIMD_CFUNC simd_mul(float  __a,  simd_float4x3 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; __x.columns[3] *= __a; return __x; }
-static  simd_float2x4 SIMD_CFUNC simd_mul(float  __a,  simd_float2x4 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; return __x; }
-static  simd_float3x4 SIMD_CFUNC simd_mul(float  __a,  simd_float3x4 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; return __x; }
-static  simd_float4x4 SIMD_CFUNC simd_mul(float  __a,  simd_float4x4 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; __x.columns[3] *= __a; return __x; }
-static simd_double2x2 SIMD_CFUNC simd_mul(double __a, simd_double2x2 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; return __x; }
-static simd_double3x2 SIMD_CFUNC simd_mul(double __a, simd_double3x2 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; return __x; }
-static simd_double4x2 SIMD_CFUNC simd_mul(double __a, simd_double4x2 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; __x.columns[3] *= __a; return __x; }
-static simd_double2x3 SIMD_CFUNC simd_mul(double __a, simd_double2x3 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; return __x; }
-static simd_double3x3 SIMD_CFUNC simd_mul(double __a, simd_double3x3 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; return __x; }
-static simd_double4x3 SIMD_CFUNC simd_mul(double __a, simd_double4x3 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; __x.columns[3] *= __a; return __x; }
-static simd_double2x4 SIMD_CFUNC simd_mul(double __a, simd_double2x4 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; return __x; }
-static simd_double3x4 SIMD_CFUNC simd_mul(double __a, simd_double3x4 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; return __x; }
-static simd_double4x4 SIMD_CFUNC simd_mul(double __a, simd_double4x4 __x) { __x.columns[0] *= __a; __x.columns[1] *= __a; __x.columns[2] *= __a; __x.columns[3] *= __a; return __x; }
-
-static  simd_float2x2 SIMD_CFUNC simd_linear_combination(float  __a,  simd_float2x2 __x, float  __b,  simd_float2x2 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    return __x;
-}
-static  simd_float3x2 SIMD_CFUNC simd_linear_combination(float  __a,  simd_float3x2 __x, float  __b,  simd_float3x2 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    __x.columns[2] = __a*__x.columns[2] + __b*__y.columns[2];
-    return __x;
-}
-static  simd_float4x2 SIMD_CFUNC simd_linear_combination(float  __a,  simd_float4x2 __x, float  __b,  simd_float4x2 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    __x.columns[2] = __a*__x.columns[2] + __b*__y.columns[2];
-    __x.columns[3] = __a*__x.columns[3] + __b*__y.columns[3];
-    return __x;
-}
-static  simd_float2x3 SIMD_CFUNC simd_linear_combination(float  __a,  simd_float2x3 __x, float  __b,  simd_float2x3 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    return __x;
-}
-static  simd_float3x3 SIMD_CFUNC simd_linear_combination(float  __a,  simd_float3x3 __x, float  __b,  simd_float3x3 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    __x.columns[2] = __a*__x.columns[2] + __b*__y.columns[2];
-    return __x;
-}
-static  simd_float4x3 SIMD_CFUNC simd_linear_combination(float  __a,  simd_float4x3 __x, float  __b,  simd_float4x3 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    __x.columns[2] = __a*__x.columns[2] + __b*__y.columns[2];
-    __x.columns[3] = __a*__x.columns[3] + __b*__y.columns[3];
-    return __x;
-}
-static  simd_float2x4 SIMD_CFUNC simd_linear_combination(float  __a,  simd_float2x4 __x, float  __b,  simd_float2x4 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    return __x;
-}
-static  simd_float3x4 SIMD_CFUNC simd_linear_combination(float  __a,  simd_float3x4 __x, float  __b,  simd_float3x4 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    __x.columns[2] = __a*__x.columns[2] + __b*__y.columns[2];
-    return __x;
-}
-static  simd_float4x4 SIMD_CFUNC simd_linear_combination(float  __a,  simd_float4x4 __x, float  __b,  simd_float4x4 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    __x.columns[2] = __a*__x.columns[2] + __b*__y.columns[2];
-    __x.columns[3] = __a*__x.columns[3] + __b*__y.columns[3];
-    return __x;
-}
-static simd_double2x2 SIMD_CFUNC simd_linear_combination(double __a, simd_double2x2 __x, double __b, simd_double2x2 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    return __x;
-}
-static simd_double3x2 SIMD_CFUNC simd_linear_combination(double __a, simd_double3x2 __x, double __b, simd_double3x2 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    __x.columns[2] = __a*__x.columns[2] + __b*__y.columns[2];
-    return __x;
-}
-static simd_double4x2 SIMD_CFUNC simd_linear_combination(double __a, simd_double4x2 __x, double __b, simd_double4x2 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    __x.columns[2] = __a*__x.columns[2] + __b*__y.columns[2];
-    __x.columns[3] = __a*__x.columns[3] + __b*__y.columns[3];
-    return __x;
-}
-static simd_double2x3 SIMD_CFUNC simd_linear_combination(double __a, simd_double2x3 __x, double __b, simd_double2x3 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    return __x;
-}
-static simd_double3x3 SIMD_CFUNC simd_linear_combination(double __a, simd_double3x3 __x, double __b, simd_double3x3 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    __x.columns[2] = __a*__x.columns[2] + __b*__y.columns[2];
-    return __x;
-}
-static simd_double4x3 SIMD_CFUNC simd_linear_combination(double __a, simd_double4x3 __x, double __b, simd_double4x3 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    __x.columns[2] = __a*__x.columns[2] + __b*__y.columns[2];
-    __x.columns[3] = __a*__x.columns[3] + __b*__y.columns[3];
-    return __x;
-}
-static simd_double2x4 SIMD_CFUNC simd_linear_combination(double __a, simd_double2x4 __x, double __b, simd_double2x4 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    return __x;
-}
-static simd_double3x4 SIMD_CFUNC simd_linear_combination(double __a, simd_double3x4 __x, double __b, simd_double3x4 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    __x.columns[2] = __a*__x.columns[2] + __b*__y.columns[2];
-    return __x;
-}
-static simd_double4x4 SIMD_CFUNC simd_linear_combination(double __a, simd_double4x4 __x, double __b, simd_double4x4 __y) {
-    __x.columns[0] = __a*__x.columns[0] + __b*__y.columns[0];
-    __x.columns[1] = __a*__x.columns[1] + __b*__y.columns[1];
-    __x.columns[2] = __a*__x.columns[2] + __b*__y.columns[2];
-    __x.columns[3] = __a*__x.columns[3] + __b*__y.columns[3];
-    return __x;
-}
-  
-static simd_float2x2 SIMD_CFUNC simd_add(simd_float2x2 __x, simd_float2x2 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_float3x2 SIMD_CFUNC simd_add(simd_float3x2 __x, simd_float3x2 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_float4x2 SIMD_CFUNC simd_add(simd_float4x2 __x, simd_float4x2 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_float2x3 SIMD_CFUNC simd_add(simd_float2x3 __x, simd_float2x3 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_float3x3 SIMD_CFUNC simd_add(simd_float3x3 __x, simd_float3x3 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_float4x3 SIMD_CFUNC simd_add(simd_float4x3 __x, simd_float4x3 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_float2x4 SIMD_CFUNC simd_add(simd_float2x4 __x, simd_float2x4 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_float3x4 SIMD_CFUNC simd_add(simd_float3x4 __x, simd_float3x4 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_float4x4 SIMD_CFUNC simd_add(simd_float4x4 __x, simd_float4x4 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_double2x2 SIMD_CFUNC simd_add(simd_double2x2 __x, simd_double2x2 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_double3x2 SIMD_CFUNC simd_add(simd_double3x2 __x, simd_double3x2 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_double4x2 SIMD_CFUNC simd_add(simd_double4x2 __x, simd_double4x2 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_double2x3 SIMD_CFUNC simd_add(simd_double2x3 __x, simd_double2x3 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_double3x3 SIMD_CFUNC simd_add(simd_double3x3 __x, simd_double3x3 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_double4x3 SIMD_CFUNC simd_add(simd_double4x3 __x, simd_double4x3 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_double2x4 SIMD_CFUNC simd_add(simd_double2x4 __x, simd_double2x4 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_double3x4 SIMD_CFUNC simd_add(simd_double3x4 __x, simd_double3x4 __y) { return simd_linear_combination(1, __x, 1, __y); }
-static simd_double4x4 SIMD_CFUNC simd_add(simd_double4x4 __x, simd_double4x4 __y) { return simd_linear_combination(1, __x, 1, __y); }
-      
-static simd_float2x2 SIMD_CFUNC simd_sub(simd_float2x2 __x, simd_float2x2 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_float3x2 SIMD_CFUNC simd_sub(simd_float3x2 __x, simd_float3x2 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_float4x2 SIMD_CFUNC simd_sub(simd_float4x2 __x, simd_float4x2 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_float2x3 SIMD_CFUNC simd_sub(simd_float2x3 __x, simd_float2x3 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_float3x3 SIMD_CFUNC simd_sub(simd_float3x3 __x, simd_float3x3 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_float4x3 SIMD_CFUNC simd_sub(simd_float4x3 __x, simd_float4x3 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_float2x4 SIMD_CFUNC simd_sub(simd_float2x4 __x, simd_float2x4 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_float3x4 SIMD_CFUNC simd_sub(simd_float3x4 __x, simd_float3x4 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_float4x4 SIMD_CFUNC simd_sub(simd_float4x4 __x, simd_float4x4 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_double2x2 SIMD_CFUNC simd_sub(simd_double2x2 __x, simd_double2x2 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_double3x2 SIMD_CFUNC simd_sub(simd_double3x2 __x, simd_double3x2 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_double4x2 SIMD_CFUNC simd_sub(simd_double4x2 __x, simd_double4x2 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_double2x3 SIMD_CFUNC simd_sub(simd_double2x3 __x, simd_double2x3 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_double3x3 SIMD_CFUNC simd_sub(simd_double3x3 __x, simd_double3x3 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_double4x3 SIMD_CFUNC simd_sub(simd_double4x3 __x, simd_double4x3 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_double2x4 SIMD_CFUNC simd_sub(simd_double2x4 __x, simd_double2x4 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_double3x4 SIMD_CFUNC simd_sub(simd_double3x4 __x, simd_double3x4 __y) { return simd_linear_combination(1, __x, -1, __y); }
-static simd_double4x4 SIMD_CFUNC simd_sub(simd_double4x4 __x, simd_double4x4 __y) { return simd_linear_combination(1, __x, -1, __y); }
-
-static simd_float2x2 SIMD_CFUNC simd_transpose(simd_float2x2 __x) {
-#if defined __SSE__
-    simd_float4 __x0, __x1;
-    __x0.xy = __x.columns[0];
-    __x1.xy = __x.columns[1];
-    simd_float4 __r01 = _mm_unpacklo_ps(__x0, __x1);
-    return simd_matrix(__r01.lo, __r01.hi);
-#else
-    return simd_matrix((simd_float2){__x.columns[0][0], __x.columns[1][0]},
-                               (simd_float2){__x.columns[0][1], __x.columns[1][1]});
-#endif
-}
-    
-static simd_float3x2 SIMD_CFUNC simd_transpose(simd_float2x3 __x) {
-#if defined __SSE__
-    simd_float4 __x0, __x1;
-    __x0.xyz = __x.columns[0];
-    __x1.xyz = __x.columns[1];
-    simd_float4 __r01 = _mm_unpacklo_ps(__x0, __x1);
-    simd_float4 __r2x = _mm_unpackhi_ps(__x0, __x1);
-    return simd_matrix(__r01.lo, __r01.hi, __r2x.lo);
-#else
-    return simd_matrix((simd_float2){__x.columns[0][0], __x.columns[1][0]},
-                               (simd_float2){__x.columns[0][1], __x.columns[1][1]},
-                               (simd_float2){__x.columns[0][2], __x.columns[1][2]});
-#endif
-}
-    
-static simd_float4x2 SIMD_CFUNC simd_transpose(simd_float2x4 __x) {
-#if defined __SSE__
-    simd_float4 __r01 = _mm_unpacklo_ps(__x.columns[0], __x.columns[1]);
-    simd_float4 __r23 = _mm_unpackhi_ps(__x.columns[0], __x.columns[1]);
-    return simd_matrix(__r01.lo, __r01.hi, __r23.lo, __r23.hi);
-#else
-    return simd_matrix((simd_float2){__x.columns[0][0], __x.columns[1][0]},
-                               (simd_float2){__x.columns[0][1], __x.columns[1][1]},
-                               (simd_float2){__x.columns[0][2], __x.columns[1][2]},
-                               (simd_float2){__x.columns[0][3], __x.columns[1][3]});
-#endif
-}
-    
-static simd_float2x3 SIMD_CFUNC simd_transpose(simd_float3x2 __x) {
-#if defined __SSE__
-    simd_float4 __x0, __x1, __x2;
-    __x0.xy = __x.columns[0];
-    __x1.xy = __x.columns[1];
-    __x2.xy = __x.columns[2];
-    simd_float4 __t = _mm_unpacklo_ps(__x0, __x1);
-    simd_float4 __r0 = _mm_shuffle_ps(__t,__x2,0xc4);
-    simd_float4 __r1 = _mm_shuffle_ps(__t,__x2,0xde);
-    return simd_matrix(__r0.xyz, __r1.xyz);
-#else
-    return simd_matrix((simd_float3){__x.columns[0][0], __x.columns[1][0], __x.columns[2][0]},
-                               (simd_float3){__x.columns[0][1], __x.columns[1][1], __x.columns[2][1]});
-#endif
-}
-    
-static simd_float3x3 SIMD_CFUNC simd_transpose(simd_float3x3 __x) {
-#if defined __SSE__
-    simd_float4 __x0, __x1, __x2;
-    __x0.xyz = __x.columns[0];
-    __x1.xyz = __x.columns[1];
-    __x2.xyz = __x.columns[2];
-    simd_float4 __t0 = _mm_unpacklo_ps(__x0, __x1);
-    simd_float4 __t1 = _mm_unpackhi_ps(__x0, __x1);
-    simd_float4 __r0 = __t0; __r0.hi = __x2.lo;
-    simd_float4 __r1 = _mm_shuffle_ps(__t0, __x2, 0xde);
-    simd_float4 __r2 = __x2; __r2.lo = __t1.lo;
-    return simd_matrix(__r0.xyz, __r1.xyz, __r2.xyz);
-#else
-    return simd_matrix((simd_float3){__x.columns[0][0], __x.columns[1][0], __x.columns[2][0]},
-                               (simd_float3){__x.columns[0][1], __x.columns[1][1], __x.columns[2][1]},
-                               (simd_float3){__x.columns[0][2], __x.columns[1][2], __x.columns[2][2]});
-#endif
-}
-    
-static simd_float4x3 SIMD_CFUNC simd_transpose(simd_float3x4 __x) {
-#if defined __SSE__
-    simd_float4 __t0 = _mm_unpacklo_ps(__x.columns[0],__x.columns[1]); /* 00 10 01 11 */
-    simd_float4 __t1 = _mm_unpackhi_ps(__x.columns[0],__x.columns[1]); /* 02 12 03 13 */
-    simd_float4 __r0 = __t0; __r0.hi = __x.columns[2].lo;
-    simd_float4 __r1 = _mm_shuffle_ps(__t0, __x.columns[2], 0xde);
-    simd_float4 __r2 = __x.columns[2]; __r2.lo = __t1.lo;
-    simd_float4 __r3 = _mm_shuffle_ps(__t1, __x.columns[2], 0xfe);
-    return simd_matrix(__r0.xyz, __r1.xyz, __r2.xyz, __r3.xyz);
-#else
-    return simd_matrix((simd_float3){__x.columns[0][0], __x.columns[1][0], __x.columns[2][0]},
-                               (simd_float3){__x.columns[0][1], __x.columns[1][1], __x.columns[2][1]},
-                               (simd_float3){__x.columns[0][2], __x.columns[1][2], __x.columns[2][2]},
-                               (simd_float3){__x.columns[0][3], __x.columns[1][3], __x.columns[2][3]});
-#endif
-}
-
-static simd_float2x4 SIMD_CFUNC simd_transpose(simd_float4x2 __x) {
-#if defined __SSE__
-    simd_float4 __x0, __x1, __x2, __x3;
-    __x0.xy = __x.columns[0];
-    __x1.xy = __x.columns[1];
-    __x2.xy = __x.columns[2];
-    __x3.xy = __x.columns[3];
-    simd_float4 __t0 = _mm_unpacklo_ps(__x0,__x2);
-    simd_float4 __t1 = _mm_unpacklo_ps(__x1,__x3);
-    simd_float4 __r0 = _mm_unpacklo_ps(__t0,__t1);
-    simd_float4 __r1 = _mm_unpackhi_ps(__t0,__t1);
-    return simd_matrix(__r0,__r1);
-#else
-    return simd_matrix((simd_float4){__x.columns[0][0], __x.columns[1][0], __x.columns[2][0], __x.columns[3][0]},
-                               (simd_float4){__x.columns[0][1], __x.columns[1][1], __x.columns[2][1], __x.columns[3][1]});
-#endif
-}
-
-static simd_float3x4 SIMD_CFUNC simd_transpose(simd_float4x3 __x) {
-#if defined __SSE__
-    simd_float4 __x0, __x1, __x2, __x3;
-    __x0.xyz = __x.columns[0];
-    __x1.xyz = __x.columns[1];
-    __x2.xyz = __x.columns[2];
-    __x3.xyz = __x.columns[3];
-    simd_float4 __t0 = _mm_unpacklo_ps(__x0,__x2);
-    simd_float4 __t1 = _mm_unpackhi_ps(__x0,__x2);
-    simd_float4 __t2 = _mm_unpacklo_ps(__x1,__x3);
-    simd_float4 __t3 = _mm_unpackhi_ps(__x1,__x3);
-    simd_float4 __r0 = _mm_unpacklo_ps(__t0,__t2);
-    simd_float4 __r1 = _mm_unpackhi_ps(__t0,__t2);
-    simd_float4 __r2 = _mm_unpacklo_ps(__t1,__t3);
-    return simd_matrix(__r0,__r1,__r2);
-#else
-    return simd_matrix((simd_float4){__x.columns[0][0], __x.columns[1][0], __x.columns[2][0], __x.columns[3][0]},
-                               (simd_float4){__x.columns[0][1], __x.columns[1][1], __x.columns[2][1], __x.columns[3][1]},
-                               (simd_float4){__x.columns[0][2], __x.columns[1][2], __x.columns[2][2], __x.columns[3][2]});
-#endif
-}
-
-static simd_float4x4 SIMD_CFUNC simd_transpose(simd_float4x4 __x) {
-#if defined __SSE__
-    simd_float4 __t0 = _mm_unpacklo_ps(__x.columns[0],__x.columns[2]);
-    simd_float4 __t1 = _mm_unpackhi_ps(__x.columns[0],__x.columns[2]);
-    simd_float4 __t2 = _mm_unpacklo_ps(__x.columns[1],__x.columns[3]);
-    simd_float4 __t3 = _mm_unpackhi_ps(__x.columns[1],__x.columns[3]);
-    simd_float4 __r0 = _mm_unpacklo_ps(__t0,__t2);
-    simd_float4 __r1 = _mm_unpackhi_ps(__t0,__t2);
-    simd_float4 __r2 = _mm_unpacklo_ps(__t1,__t3);
-    simd_float4 __r3 = _mm_unpackhi_ps(__t1,__t3);
-    return simd_matrix(__r0,__r1,__r2,__r3);
-#else
-    return simd_matrix((simd_float4){__x.columns[0][0], __x.columns[1][0], __x.columns[2][0], __x.columns[3][0]},
-                               (simd_float4){__x.columns[0][1], __x.columns[1][1], __x.columns[2][1], __x.columns[3][1]},
-                               (simd_float4){__x.columns[0][2], __x.columns[1][2], __x.columns[2][2], __x.columns[3][2]},
-                               (simd_float4){__x.columns[0][3], __x.columns[1][3], __x.columns[2][3], __x.columns[3][3]});
-#endif
-}
-
-static simd_double2x2 SIMD_CFUNC simd_transpose(simd_double2x2 __x) {
-    return simd_matrix((simd_double2){__x.columns[0][0], __x.columns[1][0]},
-                               (simd_double2){__x.columns[0][1], __x.columns[1][1]});
-}
-
-static simd_double3x2 SIMD_CFUNC simd_transpose(simd_double2x3 __x) {
-    return simd_matrix((simd_double2){__x.columns[0][0], __x.columns[1][0]},
-                               (simd_double2){__x.columns[0][1], __x.columns[1][1]},
-                               (simd_double2){__x.columns[0][2], __x.columns[1][2]});
-}
-
-static simd_double4x2 SIMD_CFUNC simd_transpose(simd_double2x4 __x) {
-    return simd_matrix((simd_double2){__x.columns[0][0], __x.columns[1][0]},
-                               (simd_double2){__x.columns[0][1], __x.columns[1][1]},
-                               (simd_double2){__x.columns[0][2], __x.columns[1][2]},
-                               (simd_double2){__x.columns[0][3], __x.columns[1][3]});
-}
-
-static simd_double2x3 SIMD_CFUNC simd_transpose(simd_double3x2 __x) {
-    return simd_matrix((simd_double3){__x.columns[0][0], __x.columns[1][0], __x.columns[2][0]},
-                               (simd_double3){__x.columns[0][1], __x.columns[1][1], __x.columns[2][1]});
-}
-
-static simd_double3x3 SIMD_CFUNC simd_transpose(simd_double3x3 __x) {
-    return simd_matrix((simd_double3){__x.columns[0][0], __x.columns[1][0], __x.columns[2][0]},
-                               (simd_double3){__x.columns[0][1], __x.columns[1][1], __x.columns[2][1]},
-                               (simd_double3){__x.columns[0][2], __x.columns[1][2], __x.columns[2][2]});
-}
-
-static simd_double4x3 SIMD_CFUNC simd_transpose(simd_double3x4 __x) {
-    return simd_matrix((simd_double3){__x.columns[0][0], __x.columns[1][0], __x.columns[2][0]},
-                               (simd_double3){__x.columns[0][1], __x.columns[1][1], __x.columns[2][1]},
-                               (simd_double3){__x.columns[0][2], __x.columns[1][2], __x.columns[2][2]},
-                               (simd_double3){__x.columns[0][3], __x.columns[1][3], __x.columns[2][3]});
-}
-
-static simd_double2x4 SIMD_CFUNC simd_transpose(simd_double4x2 __x) {
-    return simd_matrix((simd_double4){__x.columns[0][0], __x.columns[1][0], __x.columns[2][0], __x.columns[3][0]},
-                               (simd_double4){__x.columns[0][1], __x.columns[1][1], __x.columns[2][1], __x.columns[3][1]});
-}
-
-static simd_double3x4 SIMD_CFUNC simd_transpose(simd_double4x3 __x) {
-    return simd_matrix((simd_double4){__x.columns[0][0], __x.columns[1][0], __x.columns[2][0], __x.columns[3][0]},
-                               (simd_double4){__x.columns[0][1], __x.columns[1][1], __x.columns[2][1], __x.columns[3][1]},
-                               (simd_double4){__x.columns[0][2], __x.columns[1][2], __x.columns[2][2], __x.columns[3][2]});
-}
-
-static simd_double4x4 SIMD_CFUNC simd_transpose(simd_double4x4 __x) {
-    return simd_matrix((simd_double4){__x.columns[0][0], __x.columns[1][0], __x.columns[2][0], __x.columns[3][0]},
-                               (simd_double4){__x.columns[0][1], __x.columns[1][1], __x.columns[2][1], __x.columns[3][1]},
-                               (simd_double4){__x.columns[0][2], __x.columns[1][2], __x.columns[2][2], __x.columns[3][2]},
-                               (simd_double4){__x.columns[0][3], __x.columns[1][3], __x.columns[2][3], __x.columns[3][3]});
-}
-
-static  simd_float3 SIMD_CFUNC __rotate1( simd_float3 __x) { return __builtin_shufflevector(__x,__x,1,2,0); }
-static  simd_float3 SIMD_CFUNC __rotate2( simd_float3 __x) { return __builtin_shufflevector(__x,__x,2,0,1); }
-static  simd_float4 SIMD_CFUNC __rotate1( simd_float4 __x) { return __builtin_shufflevector(__x,__x,1,2,3,0); }
-static  simd_float4 SIMD_CFUNC __rotate2( simd_float4 __x) { return __builtin_shufflevector(__x,__x,2,3,0,1); }
-static  simd_float4 SIMD_CFUNC __rotate3( simd_float4 __x) { return __builtin_shufflevector(__x,__x,3,0,1,2); }
-static simd_double3 SIMD_CFUNC __rotate1(simd_double3 __x) { return __builtin_shufflevector(__x,__x,1,2,0); }
-static simd_double3 SIMD_CFUNC __rotate2(simd_double3 __x) { return __builtin_shufflevector(__x,__x,2,0,1); }
-static simd_double4 SIMD_CFUNC __rotate1(simd_double4 __x) { return __builtin_shufflevector(__x,__x,1,2,3,0); }
-static simd_double4 SIMD_CFUNC __rotate2(simd_double4 __x) { return __builtin_shufflevector(__x,__x,2,3,0,1); }
-static simd_double4 SIMD_CFUNC __rotate3(simd_double4 __x) { return __builtin_shufflevector(__x,__x,3,0,1,2); }
-
-static  float SIMD_CFUNC simd_determinant( simd_float2x2 __x) { return __x.columns[0][0]*__x.columns[1][1] - __x.columns[0][1]*__x.columns[1][0]; }
-static double SIMD_CFUNC simd_determinant(simd_double2x2 __x) { return __x.columns[0][0]*__x.columns[1][1] - __x.columns[0][1]*__x.columns[1][0]; }
-static  float SIMD_CFUNC simd_determinant( simd_float3x3 __x) { return simd_reduce_add(__x.columns[0]*(__rotate1(__x.columns[1])*__rotate2(__x.columns[2]) - __rotate2(__x.columns[1])*__rotate1(__x.columns[2]))); }
-static double SIMD_CFUNC simd_determinant(simd_double3x3 __x) { return simd_reduce_add(__x.columns[0]*(__rotate1(__x.columns[1])*__rotate2(__x.columns[2]) - __rotate2(__x.columns[1])*__rotate1(__x.columns[2]))); }
-static  float SIMD_CFUNC simd_determinant( simd_float4x4 __x) {
-    simd_float4 codet = __x.columns[0]*(__rotate1(__x.columns[1])*(__rotate2(__x.columns[2])*__rotate3(__x.columns[3])-__rotate3(__x.columns[2])*__rotate2(__x.columns[3])) +
-                                          __rotate2(__x.columns[1])*(__rotate3(__x.columns[2])*__rotate1(__x.columns[3])-__rotate1(__x.columns[2])*__rotate3(__x.columns[3])) +
-                                          __rotate3(__x.columns[1])*(__rotate1(__x.columns[2])*__rotate2(__x.columns[3])-__rotate2(__x.columns[2])*__rotate1(__x.columns[3])));
-    return simd_reduce_add(codet.even - codet.odd);
-}
-static double SIMD_CFUNC simd_determinant(simd_double4x4 __x) {
-    simd_double4 codet = __x.columns[0]*(__rotate1(__x.columns[1])*(__rotate2(__x.columns[2])*__rotate3(__x.columns[3])-__rotate3(__x.columns[2])*__rotate2(__x.columns[3])) +
-                                           __rotate2(__x.columns[1])*(__rotate3(__x.columns[2])*__rotate1(__x.columns[3])-__rotate1(__x.columns[2])*__rotate3(__x.columns[3])) +
-                                           __rotate3(__x.columns[1])*(__rotate1(__x.columns[2])*__rotate2(__x.columns[3])-__rotate2(__x.columns[2])*__rotate1(__x.columns[3])));
-    return simd_reduce_add(codet.even - codet.odd);
-}
-
-static  simd_float2x2 SIMD_CFUNC simd_inverse( simd_float2x2 __x) { return __invert_f2(__x); }
-static  simd_float3x3 SIMD_CFUNC simd_inverse( simd_float3x3 __x) { return __invert_f3(__x); }
-static  simd_float4x4 SIMD_CFUNC simd_inverse( simd_float4x4 __x) { return __invert_f4(__x); }
-static simd_double2x2 SIMD_CFUNC simd_inverse(simd_double2x2 __x) { return __invert_d2(__x); }
-static simd_double3x3 SIMD_CFUNC simd_inverse(simd_double3x3 __x) { return __invert_d3(__x); }
-static simd_double4x4 SIMD_CFUNC simd_inverse(simd_double4x4 __x) { return __invert_d4(__x); }
-
-static  simd_float2 SIMD_CFUNC simd_mul( simd_float2x2 __x,  simd_float2 __y) {  simd_float2 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); return __r; }
-static  simd_float3 SIMD_CFUNC simd_mul( simd_float2x3 __x,  simd_float2 __y) {  simd_float3 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); return __r; }
-static  simd_float4 SIMD_CFUNC simd_mul( simd_float2x4 __x,  simd_float2 __y) {  simd_float4 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); return __r; }
-static  simd_float2 SIMD_CFUNC simd_mul( simd_float3x2 __x,  simd_float3 __y) {  simd_float2 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); __r = simd_muladd( __x.columns[2], __y[2],__r); return __r; }
-static  simd_float3 SIMD_CFUNC simd_mul( simd_float3x3 __x,  simd_float3 __y) {  simd_float3 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); __r = simd_muladd( __x.columns[2], __y[2],__r); return __r; }
-static  simd_float4 SIMD_CFUNC simd_mul( simd_float3x4 __x,  simd_float3 __y) {  simd_float4 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); __r = simd_muladd( __x.columns[2], __y[2],__r); return __r; }
-static  simd_float2 SIMD_CFUNC simd_mul( simd_float4x2 __x,  simd_float4 __y) {  simd_float2 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); __r = simd_muladd( __x.columns[2], __y[2],__r); __r = simd_muladd( __x.columns[3], __y[3],__r); return __r; }
-static  simd_float3 SIMD_CFUNC simd_mul( simd_float4x3 __x,  simd_float4 __y) {  simd_float3 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); __r = simd_muladd( __x.columns[2], __y[2],__r); __r = simd_muladd( __x.columns[3], __y[3],__r); return __r; }
-static  simd_float4 SIMD_CFUNC simd_mul( simd_float4x4 __x,  simd_float4 __y) {  simd_float4 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); __r = simd_muladd( __x.columns[2], __y[2],__r); __r = simd_muladd( __x.columns[3], __y[3],__r); return __r; }
-static simd_double2 SIMD_CFUNC simd_mul(simd_double2x2 __x, simd_double2 __y) { simd_double2 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); return __r; }
-static simd_double3 SIMD_CFUNC simd_mul(simd_double2x3 __x, simd_double2 __y) { simd_double3 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); return __r; }
-static simd_double4 SIMD_CFUNC simd_mul(simd_double2x4 __x, simd_double2 __y) { simd_double4 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); return __r; }
-static simd_double2 SIMD_CFUNC simd_mul(simd_double3x2 __x, simd_double3 __y) { simd_double2 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); __r = simd_muladd( __x.columns[2], __y[2],__r); return __r; }
-static simd_double3 SIMD_CFUNC simd_mul(simd_double3x3 __x, simd_double3 __y) { simd_double3 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); __r = simd_muladd( __x.columns[2], __y[2],__r); return __r; }
-static simd_double4 SIMD_CFUNC simd_mul(simd_double3x4 __x, simd_double3 __y) { simd_double4 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); __r = simd_muladd( __x.columns[2], __y[2],__r); return __r; }
-static simd_double2 SIMD_CFUNC simd_mul(simd_double4x2 __x, simd_double4 __y) { simd_double2 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); __r = simd_muladd( __x.columns[2], __y[2],__r); __r = simd_muladd( __x.columns[3], __y[3],__r); return __r; }
-static simd_double3 SIMD_CFUNC simd_mul(simd_double4x3 __x, simd_double4 __y) { simd_double3 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); __r = simd_muladd( __x.columns[2], __y[2],__r); __r = simd_muladd( __x.columns[3], __y[3],__r); return __r; }
-static simd_double4 SIMD_CFUNC simd_mul(simd_double4x4 __x, simd_double4 __y) { simd_double4 __r = __x.columns[0]*__y[0]; __r = simd_muladd( __x.columns[1], __y[1],__r); __r = simd_muladd( __x.columns[2], __y[2],__r); __r = simd_muladd( __x.columns[3], __y[3],__r); return __r; }
-
-static  simd_float2 SIMD_CFUNC simd_mul( simd_float2 __x,  simd_float2x2 __y) { return simd_mul(simd_transpose(__y), __x); }
-static  simd_float3 SIMD_CFUNC simd_mul( simd_float2 __x,  simd_float3x2 __y) { return simd_mul(simd_transpose(__y), __x); }
-static  simd_float4 SIMD_CFUNC simd_mul( simd_float2 __x,  simd_float4x2 __y) { return simd_mul(simd_transpose(__y), __x); }
-static  simd_float2 SIMD_CFUNC simd_mul( simd_float3 __x,  simd_float2x3 __y) { return simd_mul(simd_transpose(__y), __x); }
-static  simd_float3 SIMD_CFUNC simd_mul( simd_float3 __x,  simd_float3x3 __y) { return simd_mul(simd_transpose(__y), __x); }
-static  simd_float4 SIMD_CFUNC simd_mul( simd_float3 __x,  simd_float4x3 __y) { return simd_mul(simd_transpose(__y), __x); }
-static  simd_float2 SIMD_CFUNC simd_mul( simd_float4 __x,  simd_float2x4 __y) { return simd_mul(simd_transpose(__y), __x); }
-static  simd_float3 SIMD_CFUNC simd_mul( simd_float4 __x,  simd_float3x4 __y) { return simd_mul(simd_transpose(__y), __x); }
-static  simd_float4 SIMD_CFUNC simd_mul( simd_float4 __x,  simd_float4x4 __y) { return simd_mul(simd_transpose(__y), __x); }
-static simd_double2 SIMD_CFUNC simd_mul(simd_double2 __x, simd_double2x2 __y) { return simd_mul(simd_transpose(__y), __x); }
-static simd_double3 SIMD_CFUNC simd_mul(simd_double2 __x, simd_double3x2 __y) { return simd_mul(simd_transpose(__y), __x); }
-static simd_double4 SIMD_CFUNC simd_mul(simd_double2 __x, simd_double4x2 __y) { return simd_mul(simd_transpose(__y), __x); }
-static simd_double2 SIMD_CFUNC simd_mul(simd_double3 __x, simd_double2x3 __y) { return simd_mul(simd_transpose(__y), __x); }
-static simd_double3 SIMD_CFUNC simd_mul(simd_double3 __x, simd_double3x3 __y) { return simd_mul(simd_transpose(__y), __x); }
-static simd_double4 SIMD_CFUNC simd_mul(simd_double3 __x, simd_double4x3 __y) { return simd_mul(simd_transpose(__y), __x); }
-static simd_double2 SIMD_CFUNC simd_mul(simd_double4 __x, simd_double2x4 __y) { return simd_mul(simd_transpose(__y), __x); }
-static simd_double3 SIMD_CFUNC simd_mul(simd_double4 __x, simd_double3x4 __y) { return simd_mul(simd_transpose(__y), __x); }
-static simd_double4 SIMD_CFUNC simd_mul(simd_double4 __x, simd_double4x4 __y) { return simd_mul(simd_transpose(__y), __x); }
-
-static  simd_float2x2 SIMD_CFUNC simd_mul( simd_float2x2 __x,  simd_float2x2 __y) {  simd_float2x2 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double2x2 SIMD_CFUNC simd_mul(simd_double2x2 __x, simd_double2x2 __y) { simd_double2x2 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float2x3 SIMD_CFUNC simd_mul( simd_float2x3 __x,  simd_float2x2 __y) {  simd_float2x3 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double2x3 SIMD_CFUNC simd_mul(simd_double2x3 __x, simd_double2x2 __y) { simd_double2x3 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float2x4 SIMD_CFUNC simd_mul( simd_float2x4 __x,  simd_float2x2 __y) {  simd_float2x4 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double2x4 SIMD_CFUNC simd_mul(simd_double2x4 __x, simd_double2x2 __y) { simd_double2x4 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float2x2 SIMD_CFUNC simd_mul( simd_float3x2 __x,  simd_float2x3 __y) {  simd_float2x2 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double2x2 SIMD_CFUNC simd_mul(simd_double3x2 __x, simd_double2x3 __y) { simd_double2x2 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float2x3 SIMD_CFUNC simd_mul( simd_float3x3 __x,  simd_float2x3 __y) {  simd_float2x3 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double2x3 SIMD_CFUNC simd_mul(simd_double3x3 __x, simd_double2x3 __y) { simd_double2x3 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float2x4 SIMD_CFUNC simd_mul( simd_float3x4 __x,  simd_float2x3 __y) {  simd_float2x4 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double2x4 SIMD_CFUNC simd_mul(simd_double3x4 __x, simd_double2x3 __y) { simd_double2x4 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float2x2 SIMD_CFUNC simd_mul( simd_float4x2 __x,  simd_float2x4 __y) {  simd_float2x2 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double2x2 SIMD_CFUNC simd_mul(simd_double4x2 __x, simd_double2x4 __y) { simd_double2x2 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float2x3 SIMD_CFUNC simd_mul( simd_float4x3 __x,  simd_float2x4 __y) {  simd_float2x3 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double2x3 SIMD_CFUNC simd_mul(simd_double4x3 __x, simd_double2x4 __y) { simd_double2x3 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float2x4 SIMD_CFUNC simd_mul( simd_float4x4 __x,  simd_float2x4 __y) {  simd_float2x4 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double2x4 SIMD_CFUNC simd_mul(simd_double4x4 __x, simd_double2x4 __y) { simd_double2x4 __r; for (int i=0; i<2; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-
-static  simd_float3x2 SIMD_CFUNC simd_mul( simd_float2x2 __x,  simd_float3x2 __y) {  simd_float3x2 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double3x2 SIMD_CFUNC simd_mul(simd_double2x2 __x, simd_double3x2 __y) { simd_double3x2 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float3x3 SIMD_CFUNC simd_mul( simd_float2x3 __x,  simd_float3x2 __y) {  simd_float3x3 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double3x3 SIMD_CFUNC simd_mul(simd_double2x3 __x, simd_double3x2 __y) { simd_double3x3 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float3x4 SIMD_CFUNC simd_mul( simd_float2x4 __x,  simd_float3x2 __y) {  simd_float3x4 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double3x4 SIMD_CFUNC simd_mul(simd_double2x4 __x, simd_double3x2 __y) { simd_double3x4 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float3x2 SIMD_CFUNC simd_mul( simd_float3x2 __x,  simd_float3x3 __y) {  simd_float3x2 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double3x2 SIMD_CFUNC simd_mul(simd_double3x2 __x, simd_double3x3 __y) { simd_double3x2 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float3x3 SIMD_CFUNC simd_mul( simd_float3x3 __x,  simd_float3x3 __y) {  simd_float3x3 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double3x3 SIMD_CFUNC simd_mul(simd_double3x3 __x, simd_double3x3 __y) { simd_double3x3 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float3x4 SIMD_CFUNC simd_mul( simd_float3x4 __x,  simd_float3x3 __y) {  simd_float3x4 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double3x4 SIMD_CFUNC simd_mul(simd_double3x4 __x, simd_double3x3 __y) { simd_double3x4 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float3x2 SIMD_CFUNC simd_mul( simd_float4x2 __x,  simd_float3x4 __y) {  simd_float3x2 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double3x2 SIMD_CFUNC simd_mul(simd_double4x2 __x, simd_double3x4 __y) { simd_double3x2 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float3x3 SIMD_CFUNC simd_mul( simd_float4x3 __x,  simd_float3x4 __y) {  simd_float3x3 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double3x3 SIMD_CFUNC simd_mul(simd_double4x3 __x, simd_double3x4 __y) { simd_double3x3 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float3x4 SIMD_CFUNC simd_mul( simd_float4x4 __x,  simd_float3x4 __y) {  simd_float3x4 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double3x4 SIMD_CFUNC simd_mul(simd_double4x4 __x, simd_double3x4 __y) { simd_double3x4 __r; for (int i=0; i<3; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-
-static  simd_float4x2 SIMD_CFUNC simd_mul( simd_float2x2 __x,  simd_float4x2 __y) {  simd_float4x2 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double4x2 SIMD_CFUNC simd_mul(simd_double2x2 __x, simd_double4x2 __y) { simd_double4x2 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float4x3 SIMD_CFUNC simd_mul( simd_float2x3 __x,  simd_float4x2 __y) {  simd_float4x3 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double4x3 SIMD_CFUNC simd_mul(simd_double2x3 __x, simd_double4x2 __y) { simd_double4x3 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float4x4 SIMD_CFUNC simd_mul( simd_float2x4 __x,  simd_float4x2 __y) {  simd_float4x4 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double4x4 SIMD_CFUNC simd_mul(simd_double2x4 __x, simd_double4x2 __y) { simd_double4x4 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float4x2 SIMD_CFUNC simd_mul( simd_float3x2 __x,  simd_float4x3 __y) {  simd_float4x2 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double4x2 SIMD_CFUNC simd_mul(simd_double3x2 __x, simd_double4x3 __y) { simd_double4x2 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float4x3 SIMD_CFUNC simd_mul( simd_float3x3 __x,  simd_float4x3 __y) {  simd_float4x3 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double4x3 SIMD_CFUNC simd_mul(simd_double3x3 __x, simd_double4x3 __y) { simd_double4x3 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float4x4 SIMD_CFUNC simd_mul( simd_float3x4 __x,  simd_float4x3 __y) {  simd_float4x4 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double4x4 SIMD_CFUNC simd_mul(simd_double3x4 __x, simd_double4x3 __y) { simd_double4x4 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float4x2 SIMD_CFUNC simd_mul( simd_float4x2 __x,  simd_float4x4 __y) {  simd_float4x2 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double4x2 SIMD_CFUNC simd_mul(simd_double4x2 __x, simd_double4x4 __y) { simd_double4x2 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float4x3 SIMD_CFUNC simd_mul( simd_float4x3 __x,  simd_float4x4 __y) {  simd_float4x3 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double4x3 SIMD_CFUNC simd_mul(simd_double4x3 __x, simd_double4x4 __y) { simd_double4x3 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static  simd_float4x4 SIMD_CFUNC simd_mul( simd_float4x4 __x,  simd_float4x4 __y) {  simd_float4x4 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-static simd_double4x4 SIMD_CFUNC simd_mul(simd_double4x4 __x, simd_double4x4 __y) { simd_double4x4 __r; for (int i=0; i<4; ++i) __r.columns[i] = simd_mul(__x, __y.columns[i]); return __r; }
-  
-static  simd_float2 SIMD_CFUNC matrix_multiply( simd_float2x2 __x,  simd_float2 __y) { return simd_mul(__x, __y); }
-static  simd_float3 SIMD_CFUNC matrix_multiply( simd_float2x3 __x,  simd_float2 __y) { return simd_mul(__x, __y); }
-static  simd_float4 SIMD_CFUNC matrix_multiply( simd_float2x4 __x,  simd_float2 __y) { return simd_mul(__x, __y); }
-static  simd_float2 SIMD_CFUNC matrix_multiply( simd_float3x2 __x,  simd_float3 __y) { return simd_mul(__x, __y); }
-static  simd_float3 SIMD_CFUNC matrix_multiply( simd_float3x3 __x,  simd_float3 __y) { return simd_mul(__x, __y); }
-static  simd_float4 SIMD_CFUNC matrix_multiply( simd_float3x4 __x,  simd_float3 __y) { return simd_mul(__x, __y); }
-static  simd_float2 SIMD_CFUNC matrix_multiply( simd_float4x2 __x,  simd_float4 __y) { return simd_mul(__x, __y); }
-static  simd_float3 SIMD_CFUNC matrix_multiply( simd_float4x3 __x,  simd_float4 __y) { return simd_mul(__x, __y); }
-static  simd_float4 SIMD_CFUNC matrix_multiply( simd_float4x4 __x,  simd_float4 __y) { return simd_mul(__x, __y); }
-static simd_double2 SIMD_CFUNC matrix_multiply(simd_double2x2 __x, simd_double2 __y) { return simd_mul(__x, __y); }
-static simd_double3 SIMD_CFUNC matrix_multiply(simd_double2x3 __x, simd_double2 __y) { return simd_mul(__x, __y); }
-static simd_double4 SIMD_CFUNC matrix_multiply(simd_double2x4 __x, simd_double2 __y) { return simd_mul(__x, __y); }
-static simd_double2 SIMD_CFUNC matrix_multiply(simd_double3x2 __x, simd_double3 __y) { return simd_mul(__x, __y); }
-static simd_double3 SIMD_CFUNC matrix_multiply(simd_double3x3 __x, simd_double3 __y) { return simd_mul(__x, __y); }
-static simd_double4 SIMD_CFUNC matrix_multiply(simd_double3x4 __x, simd_double3 __y) { return simd_mul(__x, __y); }
-static simd_double2 SIMD_CFUNC matrix_multiply(simd_double4x2 __x, simd_double4 __y) { return simd_mul(__x, __y); }
-static simd_double3 SIMD_CFUNC matrix_multiply(simd_double4x3 __x, simd_double4 __y) { return simd_mul(__x, __y); }
-static simd_double4 SIMD_CFUNC matrix_multiply(simd_double4x4 __x, simd_double4 __y) { return simd_mul(__x, __y); }
-  
-static  simd_float2 SIMD_CFUNC matrix_multiply( simd_float2 __x,  simd_float2x2 __y) { return simd_mul(__x, __y); }
-static  simd_float3 SIMD_CFUNC matrix_multiply( simd_float2 __x,  simd_float3x2 __y) { return simd_mul(__x, __y); }
-static  simd_float4 SIMD_CFUNC matrix_multiply( simd_float2 __x,  simd_float4x2 __y) { return simd_mul(__x, __y); }
-static  simd_float2 SIMD_CFUNC matrix_multiply( simd_float3 __x,  simd_float2x3 __y) { return simd_mul(__x, __y); }
-static  simd_float3 SIMD_CFUNC matrix_multiply( simd_float3 __x,  simd_float3x3 __y) { return simd_mul(__x, __y); }
-static  simd_float4 SIMD_CFUNC matrix_multiply( simd_float3 __x,  simd_float4x3 __y) { return simd_mul(__x, __y); }
-static  simd_float2 SIMD_CFUNC matrix_multiply( simd_float4 __x,  simd_float2x4 __y) { return simd_mul(__x, __y); }
-static  simd_float3 SIMD_CFUNC matrix_multiply( simd_float4 __x,  simd_float3x4 __y) { return simd_mul(__x, __y); }
-static  simd_float4 SIMD_CFUNC matrix_multiply( simd_float4 __x,  simd_float4x4 __y) { return simd_mul(__x, __y); }
-static simd_double2 SIMD_CFUNC matrix_multiply(simd_double2 __x, simd_double2x2 __y) { return simd_mul(__x, __y); }
-static simd_double3 SIMD_CFUNC matrix_multiply(simd_double2 __x, simd_double3x2 __y) { return simd_mul(__x, __y); }
-static simd_double4 SIMD_CFUNC matrix_multiply(simd_double2 __x, simd_double4x2 __y) { return simd_mul(__x, __y); }
-static simd_double2 SIMD_CFUNC matrix_multiply(simd_double3 __x, simd_double2x3 __y) { return simd_mul(__x, __y); }
-static simd_double3 SIMD_CFUNC matrix_multiply(simd_double3 __x, simd_double3x3 __y) { return simd_mul(__x, __y); }
-static simd_double4 SIMD_CFUNC matrix_multiply(simd_double3 __x, simd_double4x3 __y) { return simd_mul(__x, __y); }
-static simd_double2 SIMD_CFUNC matrix_multiply(simd_double4 __x, simd_double2x4 __y) { return simd_mul(__x, __y); }
-static simd_double3 SIMD_CFUNC matrix_multiply(simd_double4 __x, simd_double3x4 __y) { return simd_mul(__x, __y); }
-static simd_double4 SIMD_CFUNC matrix_multiply(simd_double4 __x, simd_double4x4 __y) { return simd_mul(__x, __y); }
-  
-static  simd_float2x2 SIMD_CFUNC matrix_multiply( simd_float2x2 __x,  simd_float2x2 __y) { return simd_mul(__x, __y); }
-static simd_double2x2 SIMD_CFUNC matrix_multiply(simd_double2x2 __x, simd_double2x2 __y) { return simd_mul(__x, __y); }
-static  simd_float2x3 SIMD_CFUNC matrix_multiply( simd_float2x3 __x,  simd_float2x2 __y) { return simd_mul(__x, __y); }
-static simd_double2x3 SIMD_CFUNC matrix_multiply(simd_double2x3 __x, simd_double2x2 __y) { return simd_mul(__x, __y); }
-static  simd_float2x4 SIMD_CFUNC matrix_multiply( simd_float2x4 __x,  simd_float2x2 __y) { return simd_mul(__x, __y); }
-static simd_double2x4 SIMD_CFUNC matrix_multiply(simd_double2x4 __x, simd_double2x2 __y) { return simd_mul(__x, __y); }
-static  simd_float2x2 SIMD_CFUNC matrix_multiply( simd_float3x2 __x,  simd_float2x3 __y) { return simd_mul(__x, __y); }
-static simd_double2x2 SIMD_CFUNC matrix_multiply(simd_double3x2 __x, simd_double2x3 __y) { return simd_mul(__x, __y); }
-static  simd_float2x3 SIMD_CFUNC matrix_multiply( simd_float3x3 __x,  simd_float2x3 __y) { return simd_mul(__x, __y); }
-static simd_double2x3 SIMD_CFUNC matrix_multiply(simd_double3x3 __x, simd_double2x3 __y) { return simd_mul(__x, __y); }
-static  simd_float2x4 SIMD_CFUNC matrix_multiply( simd_float3x4 __x,  simd_float2x3 __y) { return simd_mul(__x, __y); }
-static simd_double2x4 SIMD_CFUNC matrix_multiply(simd_double3x4 __x, simd_double2x3 __y) { return simd_mul(__x, __y); }
-static  simd_float2x2 SIMD_CFUNC matrix_multiply( simd_float4x2 __x,  simd_float2x4 __y) { return simd_mul(__x, __y); }
-static simd_double2x2 SIMD_CFUNC matrix_multiply(simd_double4x2 __x, simd_double2x4 __y) { return simd_mul(__x, __y); }
-static  simd_float2x3 SIMD_CFUNC matrix_multiply( simd_float4x3 __x,  simd_float2x4 __y) { return simd_mul(__x, __y); }
-static simd_double2x3 SIMD_CFUNC matrix_multiply(simd_double4x3 __x, simd_double2x4 __y) { return simd_mul(__x, __y); }
-static  simd_float2x4 SIMD_CFUNC matrix_multiply( simd_float4x4 __x,  simd_float2x4 __y) { return simd_mul(__x, __y); }
-static simd_double2x4 SIMD_CFUNC matrix_multiply(simd_double4x4 __x, simd_double2x4 __y) { return simd_mul(__x, __y); }
-  
-static  simd_float3x2 SIMD_CFUNC matrix_multiply( simd_float2x2 __x,  simd_float3x2 __y) { return simd_mul(__x, __y); }
-static simd_double3x2 SIMD_CFUNC matrix_multiply(simd_double2x2 __x, simd_double3x2 __y) { return simd_mul(__x, __y); }
-static  simd_float3x3 SIMD_CFUNC matrix_multiply( simd_float2x3 __x,  simd_float3x2 __y) { return simd_mul(__x, __y); }
-static simd_double3x3 SIMD_CFUNC matrix_multiply(simd_double2x3 __x, simd_double3x2 __y) { return simd_mul(__x, __y); }
-static  simd_float3x4 SIMD_CFUNC matrix_multiply( simd_float2x4 __x,  simd_float3x2 __y) { return simd_mul(__x, __y); }
-static simd_double3x4 SIMD_CFUNC matrix_multiply(simd_double2x4 __x, simd_double3x2 __y) { return simd_mul(__x, __y); }
-static  simd_float3x2 SIMD_CFUNC matrix_multiply( simd_float3x2 __x,  simd_float3x3 __y) { return simd_mul(__x, __y); }
-static simd_double3x2 SIMD_CFUNC matrix_multiply(simd_double3x2 __x, simd_double3x3 __y) { return simd_mul(__x, __y); }
-static  simd_float3x3 SIMD_CFUNC matrix_multiply( simd_float3x3 __x,  simd_float3x3 __y) { return simd_mul(__x, __y); }
-static simd_double3x3 SIMD_CFUNC matrix_multiply(simd_double3x3 __x, simd_double3x3 __y) { return simd_mul(__x, __y); }
-static  simd_float3x4 SIMD_CFUNC matrix_multiply( simd_float3x4 __x,  simd_float3x3 __y) { return simd_mul(__x, __y); }
-static simd_double3x4 SIMD_CFUNC matrix_multiply(simd_double3x4 __x, simd_double3x3 __y) { return simd_mul(__x, __y); }
-static  simd_float3x2 SIMD_CFUNC matrix_multiply( simd_float4x2 __x,  simd_float3x4 __y) { return simd_mul(__x, __y); }
-static simd_double3x2 SIMD_CFUNC matrix_multiply(simd_double4x2 __x, simd_double3x4 __y) { return simd_mul(__x, __y); }
-static  simd_float3x3 SIMD_CFUNC matrix_multiply( simd_float4x3 __x,  simd_float3x4 __y) { return simd_mul(__x, __y); }
-static simd_double3x3 SIMD_CFUNC matrix_multiply(simd_double4x3 __x, simd_double3x4 __y) { return simd_mul(__x, __y); }
-static  simd_float3x4 SIMD_CFUNC matrix_multiply( simd_float4x4 __x,  simd_float3x4 __y) { return simd_mul(__x, __y); }
-static simd_double3x4 SIMD_CFUNC matrix_multiply(simd_double4x4 __x, simd_double3x4 __y) { return simd_mul(__x, __y); }
-  
-static  simd_float4x2 SIMD_CFUNC matrix_multiply( simd_float2x2 __x,  simd_float4x2 __y) { return simd_mul(__x, __y); }
-static simd_double4x2 SIMD_CFUNC matrix_multiply(simd_double2x2 __x, simd_double4x2 __y) { return simd_mul(__x, __y); }
-static  simd_float4x3 SIMD_CFUNC matrix_multiply( simd_float2x3 __x,  simd_float4x2 __y) { return simd_mul(__x, __y); }
-static simd_double4x3 SIMD_CFUNC matrix_multiply(simd_double2x3 __x, simd_double4x2 __y) { return simd_mul(__x, __y); }
-static  simd_float4x4 SIMD_CFUNC matrix_multiply( simd_float2x4 __x,  simd_float4x2 __y) { return simd_mul(__x, __y); }
-static simd_double4x4 SIMD_CFUNC matrix_multiply(simd_double2x4 __x, simd_double4x2 __y) { return simd_mul(__x, __y); }
-static  simd_float4x2 SIMD_CFUNC matrix_multiply( simd_float3x2 __x,  simd_float4x3 __y) { return simd_mul(__x, __y); }
-static simd_double4x2 SIMD_CFUNC matrix_multiply(simd_double3x2 __x, simd_double4x3 __y) { return simd_mul(__x, __y); }
-static  simd_float4x3 SIMD_CFUNC matrix_multiply( simd_float3x3 __x,  simd_float4x3 __y) { return simd_mul(__x, __y); }
-static simd_double4x3 SIMD_CFUNC matrix_multiply(simd_double3x3 __x, simd_double4x3 __y) { return simd_mul(__x, __y); }
-static  simd_float4x4 SIMD_CFUNC matrix_multiply( simd_float3x4 __x,  simd_float4x3 __y) { return simd_mul(__x, __y); }
-static simd_double4x4 SIMD_CFUNC matrix_multiply(simd_double3x4 __x, simd_double4x3 __y) { return simd_mul(__x, __y); }
-static  simd_float4x2 SIMD_CFUNC matrix_multiply( simd_float4x2 __x,  simd_float4x4 __y) { return simd_mul(__x, __y); }
-static simd_double4x2 SIMD_CFUNC matrix_multiply(simd_double4x2 __x, simd_double4x4 __y) { return simd_mul(__x, __y); }
-static  simd_float4x3 SIMD_CFUNC matrix_multiply( simd_float4x3 __x,  simd_float4x4 __y) { return simd_mul(__x, __y); }
-static simd_double4x3 SIMD_CFUNC matrix_multiply(simd_double4x3 __x, simd_double4x4 __y) { return simd_mul(__x, __y); }
-static  simd_float4x4 SIMD_CFUNC matrix_multiply( simd_float4x4 __x,  simd_float4x4 __y) { return simd_mul(__x, __y); }
-static simd_double4x4 SIMD_CFUNC matrix_multiply(simd_double4x4 __x, simd_double4x4 __y) { return simd_mul(__x, __y); }
-
-static simd_bool SIMD_CFUNC simd_equal(simd_float2x2 __x, simd_float2x2 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_float2x3 __x, simd_float2x3 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_float2x4 __x, simd_float2x4 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_float3x2 __x, simd_float3x2 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]) &
-                      (__x.columns[2] == __y.columns[2]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_float3x3 __x, simd_float3x3 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]) &
-                      (__x.columns[2] == __y.columns[2]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_float3x4 __x, simd_float3x4 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]) &
-                      (__x.columns[2] == __y.columns[2]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_float4x2 __x, simd_float4x2 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]) &
-                      (__x.columns[2] == __y.columns[2]) &
-                      (__x.columns[3] == __y.columns[3]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_float4x3 __x, simd_float4x3 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]) &
-                      (__x.columns[2] == __y.columns[2]) &
-                      (__x.columns[3] == __y.columns[3]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_float4x4 __x, simd_float4x4 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]) &
-                      (__x.columns[2] == __y.columns[2]) &
-                      (__x.columns[3] == __y.columns[3]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_double2x2 __x, simd_double2x2 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_double2x3 __x, simd_double2x3 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_double2x4 __x, simd_double2x4 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_double3x2 __x, simd_double3x2 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]) &
-                      (__x.columns[2] == __y.columns[2]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_double3x3 __x, simd_double3x3 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]) &
-                      (__x.columns[2] == __y.columns[2]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_double3x4 __x, simd_double3x4 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]) &
-                      (__x.columns[2] == __y.columns[2]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_double4x2 __x, simd_double4x2 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]) &
-                      (__x.columns[2] == __y.columns[2]) &
-                      (__x.columns[3] == __y.columns[3]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_double4x3 __x, simd_double4x3 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]) &
-                      (__x.columns[2] == __y.columns[2]) &
-                      (__x.columns[3] == __y.columns[3]));
-}
-static simd_bool SIMD_CFUNC simd_equal(simd_double4x4 __x, simd_double4x4 __y) {
-    return simd_all((__x.columns[0] == __y.columns[0]) &
-                      (__x.columns[1] == __y.columns[1]) &
-                      (__x.columns[2] == __y.columns[2]) &
-                      (__x.columns[3] == __y.columns[3]));
-}
-
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float2x2 __x, simd_float2x2 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float2x3 __x, simd_float2x3 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float2x4 __x, simd_float2x4 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float3x2 __x, simd_float3x2 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float3x3 __x, simd_float3x3 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float3x4 __x, simd_float3x4 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float4x2 __x, simd_float4x2 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol) &
-                      (__tg_fabs(__x.columns[3] - __y.columns[3]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float4x3 __x, simd_float4x3 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol) &
-                      (__tg_fabs(__x.columns[3] - __y.columns[3]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_float4x4 __x, simd_float4x4 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol) &
-                      (__tg_fabs(__x.columns[3] - __y.columns[3]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double2x2 __x, simd_double2x2 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double2x3 __x, simd_double2x3 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double2x4 __x, simd_double2x4 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double3x2 __x, simd_double3x2 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double3x3 __x, simd_double3x3 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double3x4 __x, simd_double3x4 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double4x2 __x, simd_double4x2 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol) &
-                      (__tg_fabs(__x.columns[3] - __y.columns[3]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double4x3 __x, simd_double4x3 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol) &
-                      (__tg_fabs(__x.columns[3] - __y.columns[3]) <= __tol));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements(simd_double4x4 __x, simd_double4x4 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol) &
-                      (__tg_fabs(__x.columns[3] - __y.columns[3]) <= __tol));
-}
-
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float2x2 __x, simd_float2x2 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float2x3 __x, simd_float2x3 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float2x4 __x, simd_float2x4 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float3x2 __x, simd_float3x2 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol*__tg_fabs(__x.columns[2])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float3x3 __x, simd_float3x3 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol*__tg_fabs(__x.columns[2])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float3x4 __x, simd_float3x4 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol*__tg_fabs(__x.columns[2])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float4x2 __x, simd_float4x2 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol*__tg_fabs(__x.columns[2])) &
-                      (__tg_fabs(__x.columns[3] - __y.columns[3]) <= __tol*__tg_fabs(__x.columns[3])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float4x3 __x, simd_float4x3 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol*__tg_fabs(__x.columns[2])) &
-                      (__tg_fabs(__x.columns[3] - __y.columns[3]) <= __tol*__tg_fabs(__x.columns[3])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_float4x4 __x, simd_float4x4 __y, float __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol*__tg_fabs(__x.columns[2])) &
-                      (__tg_fabs(__x.columns[3] - __y.columns[3]) <= __tol*__tg_fabs(__x.columns[3])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double2x2 __x, simd_double2x2 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double2x3 __x, simd_double2x3 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double2x4 __x, simd_double2x4 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double3x2 __x, simd_double3x2 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol*__tg_fabs(__x.columns[2])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double3x3 __x, simd_double3x3 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol*__tg_fabs(__x.columns[2])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double3x4 __x, simd_double3x4 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol*__tg_fabs(__x.columns[2])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double4x2 __x, simd_double4x2 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol*__tg_fabs(__x.columns[2])) &
-                      (__tg_fabs(__x.columns[3] - __y.columns[3]) <= __tol*__tg_fabs(__x.columns[3])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double4x3 __x, simd_double4x3 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol*__tg_fabs(__x.columns[2])) &
-                      (__tg_fabs(__x.columns[3] - __y.columns[3]) <= __tol*__tg_fabs(__x.columns[3])));
-}
-static simd_bool SIMD_CFUNC simd_almost_equal_elements_relative(simd_double4x4 __x, simd_double4x4 __y, double __tol) {
-    return simd_all((__tg_fabs(__x.columns[0] - __y.columns[0]) <= __tol*__tg_fabs(__x.columns[0])) &
-                      (__tg_fabs(__x.columns[1] - __y.columns[1]) <= __tol*__tg_fabs(__x.columns[1])) &
-                      (__tg_fabs(__x.columns[2] - __y.columns[2]) <= __tol*__tg_fabs(__x.columns[2])) &
-                      (__tg_fabs(__x.columns[3] - __y.columns[3]) <= __tol*__tg_fabs(__x.columns[3])));
-}
-    
-#ifdef __cplusplus
-}
-#endif
-#endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */
-#endif /* __SIMD_HEADER__ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/simd/matrix_types.h b/lib/libc/include/x86_64-macos.10-none/simd/matrix_types.h
deleted file mode 100644
index 904df687a6..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/simd/matrix_types.h
+++ /dev/null
@@ -1,264 +0,0 @@
-/*  Copyright (c) 2014-2017 Apple, Inc. All rights reserved.
- *
- *  This header defines nine matrix types for each of float and double, which
- *  are intended for use together with the vector types defined in
- *  <simd/vector_types.h>.
- *
- *  For compatibility with common graphics libraries, these matrices are stored
- *  in column-major order, and implemented as arrays of column vectors.
- *  Column-major storage order may seem a little strange if you aren't used to
- *  it, but for most usage the memory layout of the matrices shouldn't matter
- *  at all; instead you should think of matrices as abstract mathematical
- *  objects that you use to perform arithmetic without worrying about the
- *  details of the underlying representation.
- *
- *  WARNING: vectors of length three are internally represented as length four
- *  vectors with one element of padding (for alignment purposes).  This means
- *  that when a floatNx3 or doubleNx3 is viewed as a vector, it appears to
- *  have 4*N elements instead of the expected 3*N (with one padding element
- *  at the end of each column).  The matrix elements are laid out in memory
- *  as follows:
- *
- *      { 0, 1, 2, x, 3, 4, 5, x, ... }
- *
- *  (where the scalar indices used above indicate the conceptual column-
- *  major storage order).  If you aren't monkeying around with the internal
- *  storage details of matrices, you don't need to worry about this at all.
- *  Consider this yet another good reason to avoid doing so.                  */
-
-#ifndef SIMD_MATRIX_TYPES_HEADER
-#define SIMD_MATRIX_TYPES_HEADER
-
-#include <simd/types.h>
-#if SIMD_COMPILER_HAS_REQUIRED_FEATURES
-
-/*  Matrix types available in C, Objective-C, and C++                         */
-typedef simd_float2x2 matrix_float2x2;
-typedef simd_float3x2 matrix_float3x2;
-typedef simd_float4x2 matrix_float4x2;
-
-typedef simd_float2x3 matrix_float2x3;
-typedef simd_float3x3 matrix_float3x3;
-typedef simd_float4x3 matrix_float4x3;
-
-typedef simd_float2x4 matrix_float2x4;
-typedef simd_float3x4 matrix_float3x4;
-typedef simd_float4x4 matrix_float4x4;
-
-typedef simd_double2x2 matrix_double2x2;
-typedef simd_double3x2 matrix_double3x2;
-typedef simd_double4x2 matrix_double4x2;
-
-typedef simd_double2x3 matrix_double2x3;
-typedef simd_double3x3 matrix_double3x3;
-typedef simd_double4x3 matrix_double4x3;
-
-typedef simd_double2x4 matrix_double2x4;
-typedef simd_double3x4 matrix_double3x4;
-typedef simd_double4x4 matrix_double4x4;
-
-#ifdef __cplusplus
-#if defined SIMD_MATRIX_HEADER
-static  simd_float3x3 SIMD_NOINLINE simd_matrix3x3(simd_quatf q);
-static  simd_float4x4 SIMD_NOINLINE simd_matrix4x4(simd_quatf q);
-static simd_double3x3 SIMD_NOINLINE simd_matrix3x3(simd_quatd q);
-static simd_double4x4 SIMD_NOINLINE simd_matrix4x4(simd_quatd q);
-#endif
-
-namespace simd {
-  
-  struct float2x2 : ::simd_float2x2 {
-    float2x2() { columns[0] = 0; columns[1] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    float2x2(float diagonal) : float2x2((float2)diagonal) { }
-#endif
-    float2x2(float2 v) { columns[0] = (float2){v.x,0}; columns[1] = (float2){0,v.y}; }
-    float2x2(float2 c0, float2 c1) { columns[0] = c0; columns[1] = c1; }
-    float2x2(::simd_float2x2 m) : ::simd_float2x2(m) { }
-  };
-  
-  struct float3x2 : ::simd_float3x2 {
-    float3x2() { columns[0] = 0; columns[1] = 0; columns[2] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    float3x2(float diagonal) : float3x2((float2)diagonal) { }
-#endif
-    float3x2(float2 v) { columns[0] = (float2){v.x,0}; columns[1] = (float2){0,v.y}; columns[2] = 0; }
-    float3x2(float2 c0, float2 c1, float2 c2) { columns[0] = c0; columns[1] = c1; columns[2] = c2; }
-    float3x2(::simd_float3x2 m) : ::simd_float3x2(m) { }
-  };
-  
-  struct float4x2 : ::simd_float4x2 {
-    float4x2() { columns[0] = 0; columns[1] = 0; columns[2] = 0; columns[3] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    float4x2(float diagonal) : float4x2((float2)diagonal) { }
-#endif
-    float4x2(float2 v) { columns[0] = (float2){v.x,0}; columns[1] = (float2){0,v.y}; columns[2] = 0; columns[3] = 0; }
-    float4x2(float2 c0, float2 c1, float2 c2, float2 c3) { columns[0] = c0; columns[1] = c1; columns[2] = c2; columns[3] = c3; }
-    float4x2(::simd_float4x2 m) : ::simd_float4x2(m) { }
-  };
-  
-  struct float2x3 : ::simd_float2x3 {
-    float2x3() { columns[0] = 0; columns[1] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    float2x3(float diagonal) : float2x3((float2)diagonal) { }
-#endif
-    float2x3(float2 v) { columns[0] = (float3){v.x,0,0}; columns[1] = (float3){0,v.y,0}; }
-    float2x3(float3 c0, float3 c1) { columns[0] = c0; columns[1] = c1; }
-    float2x3(::simd_float2x3 m) : ::simd_float2x3(m) { }
-  };
-  
-  struct float3x3 : ::simd_float3x3 {
-    float3x3() { columns[0] = 0; columns[1] = 0; columns[2] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    float3x3(float diagonal) : float3x3((float3)diagonal) { }
-#endif
-    float3x3(float3 v) { columns[0] = (float3){v.x,0,0}; columns[1] = (float3){0,v.y,0}; columns[2] = (float3){0,0,v.z}; }
-    float3x3(float3 c0, float3 c1, float3 c2) { columns[0] = c0; columns[1] = c1; columns[2] = c2; }
-    float3x3(::simd_float3x3 m) : ::simd_float3x3(m) { }
-#if defined SIMD_MATRIX_HEADER
-    float3x3(::simd_quatf q) : ::simd_float3x3(::simd_matrix3x3(q)) { }
-#endif
-  };
-  
-  struct float4x3 : ::simd_float4x3 {
-    float4x3() { columns[0] = 0; columns[1] = 0; columns[2] = 0; columns[3] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    float4x3(float diagonal) : float4x3((float3)diagonal) { }
-#endif
-    float4x3(float3 v) { columns[0] = (float3){v.x,0,0}; columns[1] = (float3){0,v.y,0}; columns[2] = (float3){0,0,v.z}; columns[3] = 0; }
-    float4x3(float3 c0, float3 c1, float3 c2, float3 c3) { columns[0] = c0; columns[1] = c1; columns[2] = c2; columns[3] = c3; }
-    float4x3(::simd_float4x3 m) : ::simd_float4x3(m) { }
-  };
-  
-  struct float2x4 : ::simd_float2x4 {
-    float2x4() { columns[0] = 0; columns[1] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    float2x4(float diagonal) : float2x4((float2)diagonal) { }
-#endif
-    float2x4(float2 v) { columns[0] = (float4){v.x,0,0,0}; columns[1] = (float4){0,v.y,0,0}; }
-    float2x4(float4 c0, float4 c1) { columns[0] = c0; columns[1] = c1; }
-    float2x4(::simd_float2x4 m) : ::simd_float2x4(m) { }
-  };
-  
-  struct float3x4 : ::simd_float3x4 {
-    float3x4() { columns[0] = 0; columns[1] = 0; columns[2] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    float3x4(float diagonal) : float3x4((float3)diagonal) { }
-#endif
-    float3x4(float3 v) { columns[0] = (float4){v.x,0,0,0}; columns[1] = (float4){0,v.y,0,0}; columns[2] = (float4){0,0,v.z,0}; }
-    float3x4(float4 c0, float4 c1, float4 c2) { columns[0] = c0; columns[1] = c1; columns[2] = c2; }
-    float3x4(::simd_float3x4 m) : ::simd_float3x4(m) { }
-  };
-  
-  struct float4x4 : ::simd_float4x4 {
-    float4x4() { columns[0] = 0; columns[1] = 0; columns[2] = 0; columns[3] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    float4x4(float diagonal) : float4x4((float4)diagonal) { }
-#endif
-    float4x4(float4 v) { columns[0] = (float4){v.x,0,0,0}; columns[1] = (float4){0,v.y,0,0}; columns[2] = (float4){0,0,v.z,0}; columns[3] = (float4){0,0,0,v.w}; }
-    float4x4(float4 c0, float4 c1, float4 c2, float4 c3) { columns[0] = c0; columns[1] = c1; columns[2] = c2; columns[3] = c3; }
-    float4x4(::simd_float4x4 m) : ::simd_float4x4(m) { }
-#if defined SIMD_MATRIX_HEADER
-    float4x4(::simd_quatf q) : ::simd_float4x4(::simd_matrix4x4(q)) { }
-#endif
-  };
-  
-  struct double2x2 : ::simd_double2x2 {
-    double2x2() { columns[0] = 0; columns[1] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    double2x2(double diagonal) : double2x2((double2)diagonal) { }
-#endif
-    double2x2(double2 v) { columns[0] = (double2){v.x,0}; columns[1] = (double2){0,v.y}; }
-    double2x2(double2 c0, double2 c1) { columns[0] = c0; columns[1] = c1; }
-    double2x2(::simd_double2x2 m) : ::simd_double2x2(m) { }
-  };
-  
-  struct double3x2 : ::simd_double3x2 {
-    double3x2() { columns[0] = 0; columns[1] = 0; columns[2] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    double3x2(double diagonal) : double3x2((double2)diagonal) { }
-#endif
-    double3x2(double2 v) { columns[0] = (double2){v.x,0}; columns[1] = (double2){0,v.y}; columns[2] = 0; }
-    double3x2(double2 c0, double2 c1, double2 c2) { columns[0] = c0; columns[1] = c1; columns[2] = c2; }
-    double3x2(::simd_double3x2 m) : ::simd_double3x2(m) { }
-  };
-  
-  struct double4x2 : ::simd_double4x2 {
-    double4x2() { columns[0] = 0; columns[1] = 0; columns[2] = 0; columns[3] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    double4x2(double diagonal) : double4x2((double2)diagonal) { }
-#endif
-    double4x2(double2 v) { columns[0] = (double2){v.x,0}; columns[1] = (double2){0,v.y}; columns[2] = 0; columns[3] = 0; }
-    double4x2(double2 c0, double2 c1, double2 c2, double2 c3) { columns[0] = c0; columns[1] = c1; columns[2] = c2; columns[3] = c3; }
-    double4x2(::simd_double4x2 m) : ::simd_double4x2(m) { }
-  };
-  
-  struct double2x3 : ::simd_double2x3 {
-    double2x3() { columns[0] = 0; columns[1] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    double2x3(double diagonal) : double2x3((double2)diagonal) { }
-#endif
-    double2x3(double2 v) { columns[0] = (double3){v.x,0,0}; columns[1] = (double3){0,v.y,0}; }
-    double2x3(double3 c0, double3 c1) { columns[0] = c0; columns[1] = c1; }
-    double2x3(::simd_double2x3 m) : ::simd_double2x3(m) { }
-  };
-  
-  struct double3x3 : ::simd_double3x3 {
-    double3x3() { columns[0] = 0; columns[1] = 0; columns[2] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    double3x3(double diagonal) : double3x3((double3)diagonal) { }
-#endif
-    double3x3(double3 v) { columns[0] = (double3){v.x,0,0}; columns[1] = (double3){0,v.y,0}; columns[2] = (double3){0,0,v.z}; }
-    double3x3(double3 c0, double3 c1, double3 c2) { columns[0] = c0; columns[1] = c1; columns[2] = c2; }
-    double3x3(::simd_double3x3 m) : ::simd_double3x3(m) { }
-#if defined SIMD_MATRIX_HEADER
-    double3x3(::simd_quatd q) : ::simd_double3x3(::simd_matrix3x3(q)) { }
-#endif
-  };
-  
-  struct double4x3 : ::simd_double4x3 {
-    double4x3() { columns[0] = 0; columns[1] = 0; columns[2] = 0; columns[3] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    double4x3(double diagonal) : double4x3((double3)diagonal) { }
-#endif
-    double4x3(double3 v) { columns[0] = (double3){v.x,0,0}; columns[1] = (double3){0,v.y,0}; columns[2] = (double3){0,0,v.z}; columns[3] = 0; }
-    double4x3(double3 c0, double3 c1, double3 c2, double3 c3) { columns[0] = c0; columns[1] = c1; columns[2] = c2; columns[3] = c3; }
-    double4x3(::simd_double4x3 m) : ::simd_double4x3(m) { }
-  };
-  
-  struct double2x4 : ::simd_double2x4 {
-    double2x4() { columns[0] = 0; columns[1] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    double2x4(double diagonal) : double2x4((double2)diagonal) { }
-#endif
-    double2x4(double2 v) { columns[0] = (double4){v.x,0,0,0}; columns[1] = (double4){0,v.y,0,0}; }
-    double2x4(double4 c0, double4 c1) { columns[0] = c0; columns[1] = c1; }
-    double2x4(::simd_double2x4 m) : ::simd_double2x4(m) { }
-  };
-  
-  struct double3x4 : ::simd_double3x4 {
-    double3x4() { columns[0] = 0; columns[1] = 0; columns[2] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    double3x4(double diagonal) : double3x4((double3)diagonal) { }
-#endif
-    double3x4(double3 v) { columns[0] = (double4){v.x,0,0,0}; columns[1] = (double4){0,v.y,0,0}; columns[2] = (double4){0,0,v.z,0}; }
-    double3x4(double4 c0, double4 c1, double4 c2) { columns[0] = c0; columns[1] = c1; columns[2] = c2; }
-    double3x4(::simd_double3x4 m) : ::simd_double3x4(m) { }
-  };
-  
-  struct double4x4 : ::simd_double4x4 {
-    double4x4() { columns[0] = 0; columns[1] = 0; columns[2] = 0; columns[3] = 0; }
-#if __has_feature(cxx_delegating_constructors)
-    double4x4(double diagonal) : double4x4((double4)diagonal) { }
-#endif
-    double4x4(double4 v) { columns[0] = (double4){v.x,0,0,0}; columns[1] = (double4){0,v.y,0,0}; columns[2] = (double4){0,0,v.z,0}; columns[3] = (double4){0,0,0,v.w}; }
-    double4x4(double4 c0, double4 c1, double4 c2, double4 c3) { columns[0] = c0; columns[1] = c1; columns[2] = c2; columns[3] = c3; }
-    double4x4(::simd_double4x4 m) : ::simd_double4x4(m) { }
-#if defined SIMD_MATRIX_HEADER
-    double4x4(::simd_quatd q) : ::simd_double4x4(::simd_matrix4x4(q)) { }
-#endif
-  };
-}
-#endif /* __cplusplus */
-#endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */
-#endif /* SIMD_MATRIX_TYPES_HEADER */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/simd/packed.h b/lib/libc/include/x86_64-macos.10-none/simd/packed.h
deleted file mode 100644
index dfdc199999..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/simd/packed.h
+++ /dev/null
@@ -1,1031 +0,0 @@
-/*! @header
- *  This header defines fixed size vector types with relaxed alignment. For 
- *  each vector type defined by <simd/vector_types.h> that is not a 1- or 3-
- *  element vector, there is a corresponding type defined by this header that
- *  requires only the alignment matching that of the underlying scalar type.
- *
- *  These types should be used to access buffers that may not be sufficiently
- *  aligned to allow them to be accessed using the "normal" simd vector types.
- *  As an example of this usage, suppose that you want to load a vector of
- *  four floats from an array of floats. The type simd_float4 has sixteen byte
- *  alignment, whereas an array of floats has only four byte alignment.
- *  Thus, naively casting a pointer into the array to (simd_float4 *) would 
- *  invoke undefined behavior, and likely produce an alignment fault at
- *  runtime. Instead, use the corresponding packed type to load from the array:
- *
- *  <pre>
- *  @textblock
- *  simd_float4 vector = *(packed_simd_float4 *)&array[i];
- *  // do something with vector ...
- *  @/textblock
- *  </pre>
- *
- *  It's important to note that the packed_ types are only needed to work with
- *  memory; once the data is loaded, we simply operate on it as usual using
- *  the simd_float4 type, as illustrated above.
- *
- *  @copyright 2014-2017 Apple, Inc. All rights reserved.
- *  @unsorted                                                                 */
-
-#ifndef SIMD_PACKED_TYPES
-#define SIMD_PACKED_TYPES
-
-# include <simd/vector_types.h>
-# if SIMD_COMPILER_HAS_REQUIRED_FEATURES
-/*! @abstract A vector of two 8-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_char2. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-typedef __attribute__((__ext_vector_type__(2),__aligned__(1))) char simd_packed_char2;
-
-/*! @abstract A vector of four 8-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_char4. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-typedef __attribute__((__ext_vector_type__(4),__aligned__(1))) char simd_packed_char4;
-
-/*! @abstract A vector of eight 8-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_char8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(8),__aligned__(1))) char simd_packed_char8;
-
-/*! @abstract A vector of sixteen 8-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_char16.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(16),__aligned__(1))) char simd_packed_char16;
-
-/*! @abstract A vector of thirty-two 8-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_char32.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(32),__aligned__(1))) char simd_packed_char32;
-
-/*! @abstract A vector of sixty-four 8-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_char64.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(64),__aligned__(1))) char simd_packed_char64;
-
-/*! @abstract A vector of two 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_uchar2. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(2),__aligned__(1))) unsigned char simd_packed_uchar2;
-
-/*! @abstract A vector of four 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_uchar4. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(4),__aligned__(1))) unsigned char simd_packed_uchar4;
-
-/*! @abstract A vector of eight 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_uchar8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(8),__aligned__(1))) unsigned char simd_packed_uchar8;
-
-/*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_uchar16.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(16),__aligned__(1))) unsigned char simd_packed_uchar16;
-
-/*! @abstract A vector of thirty-two 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_uchar32.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(32),__aligned__(1))) unsigned char simd_packed_uchar32;
-
-/*! @abstract A vector of sixty-four 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_uchar64.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(64),__aligned__(1))) unsigned char simd_packed_uchar64;
-
-/*! @abstract A vector of two 16-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_short2. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(2),__aligned__(2))) short simd_packed_short2;
-
-/*! @abstract A vector of four 16-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_short4. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(4),__aligned__(2))) short simd_packed_short4;
-
-/*! @abstract A vector of eight 16-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_short8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(8),__aligned__(2))) short simd_packed_short8;
-
-/*! @abstract A vector of sixteen 16-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_short16.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(16),__aligned__(2))) short simd_packed_short16;
-
-/*! @abstract A vector of thirty-two 16-bit signed (twos-complement)
- *  integers with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_short32.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(32),__aligned__(2))) short simd_packed_short32;
-
-/*! @abstract A vector of two 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_ushort2. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(2),__aligned__(2))) unsigned short simd_packed_ushort2;
-
-/*! @abstract A vector of four 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_ushort4. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(4),__aligned__(2))) unsigned short simd_packed_ushort4;
-
-/*! @abstract A vector of eight 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_ushort8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(8),__aligned__(2))) unsigned short simd_packed_ushort8;
-
-/*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as
- *  simd::packed_ushort16. This type is not available in Metal. The
- *  alignment of this type is only that of the underlying scalar element
- *  type, so you can use it to load or store from an array of that type.      */
-typedef __attribute__((__ext_vector_type__(16),__aligned__(2))) unsigned short simd_packed_ushort16;
-
-/*! @abstract A vector of thirty-two 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as
- *  simd::packed_ushort32. This type is not available in Metal. The
- *  alignment of this type is only that of the underlying scalar element
- *  type, so you can use it to load or store from an array of that type.      */
-typedef __attribute__((__ext_vector_type__(32),__aligned__(2))) unsigned short simd_packed_ushort32;
-
-/*! @abstract A vector of two 32-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_int2. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) int simd_packed_int2;
-
-/*! @abstract A vector of four 32-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_int4. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) int simd_packed_int4;
-
-/*! @abstract A vector of eight 32-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_int8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) int simd_packed_int8;
-
-/*! @abstract A vector of sixteen 32-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_int16.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) int simd_packed_int16;
-
-/*! @abstract A vector of two 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_uint2. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) unsigned int simd_packed_uint2;
-
-/*! @abstract A vector of four 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_uint4. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) unsigned int simd_packed_uint4;
-
-/*! @abstract A vector of eight 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_uint8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) unsigned int simd_packed_uint8;
-
-/*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_uint16.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) unsigned int simd_packed_uint16;
-
-/*! @abstract A vector of two 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_float2. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) float simd_packed_float2;
-
-/*! @abstract A vector of four 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_float4. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) float simd_packed_float4;
-
-/*! @abstract A vector of eight 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_float8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) float simd_packed_float8;
-
-/*! @abstract A vector of sixteen 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_float16.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) float simd_packed_float16;
-
-/*! @abstract A vector of two 64-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_long2. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) simd_long1 simd_packed_long2;
-#else
-typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) simd_long1 simd_packed_long2;
-#endif
-
-/*! @abstract A vector of four 64-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_long4. The alignment of this type is that of the underlying
- *  scalar element type, so you can use it to load or store from an array of
- *  that type.                                                                */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) simd_long1 simd_packed_long4;
-#else
-typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) simd_long1 simd_packed_long4;
-#endif
-
-/*! @abstract A vector of eight 64-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description In C++ this type is also available as simd::packed_long8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) simd_long1 simd_packed_long8;
-#else
-typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) simd_long1 simd_packed_long8;
-#endif
-
-/*! @abstract A vector of two 64-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_ulong2. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) simd_ulong1 simd_packed_ulong2;
-#else
-typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) simd_ulong1 simd_packed_ulong2;
-#endif
-
-/*! @abstract A vector of four 64-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_ulong4. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) simd_ulong1 simd_packed_ulong4;
-#else
-typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) simd_ulong1 simd_packed_ulong4;
-#endif
-
-/*! @abstract A vector of eight 64-bit unsigned integers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_ulong8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) simd_ulong1 simd_packed_ulong8;
-#else
-typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) simd_ulong1 simd_packed_ulong8;
-#endif
-
-/*! @abstract A vector of two 64-bit floating-point numbers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_double2. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) double simd_packed_double2;
-#else
-typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) double simd_packed_double2;
-#endif
-
-/*! @abstract A vector of four 64-bit floating-point numbers with relaxed
- *  alignment.
- *  @description In C++ and Metal, this type is also available as
- *  simd::packed_double4. The alignment of this type is that of the
- *  underlying scalar element type, so you can use it to load or store from
- *  an array of that type.                                                    */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) double simd_packed_double4;
-#else
-typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) double simd_packed_double4;
-#endif
-
-/*! @abstract A vector of eight 64-bit floating-point numbers with relaxed
- *  alignment.
- *  @description In C++ this type is also available as simd::packed_double8.
- *  This type is not available in Metal. The alignment of this type is only
- *  that of the underlying scalar element type, so you can use it to load or
- *  store from an array of that type.                                         */
-#if defined __LP64__
-typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) double simd_packed_double8;
-#else
-typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) double simd_packed_double8;
-#endif
-
-/*  MARK: C++ vector types                                                    */
-#if defined __cplusplus
-namespace simd {
-  namespace packed {
-    /*! @abstract A vector of two 8-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_char2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_char2 char2;
-  
-    /*! @abstract A vector of four 8-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_char4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_char4 char4;
-  
-    /*! @abstract A vector of eight 8-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_char8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_char8 char8;
-  
-    /*! @abstract A vector of sixteen 8-bit signed (twos-complement)
-     *  integers with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_char16. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_char16 char16;
-  
-    /*! @abstract A vector of thirty-two 8-bit signed (twos-complement)
-     *  integers with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_char32. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_char32 char32;
-  
-    /*! @abstract A vector of sixty-four 8-bit signed (twos-complement)
-     *  integers with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_char64. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_char64 char64;
-  
-    /*! @abstract A vector of two 8-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_uchar2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_uchar2 uchar2;
-  
-    /*! @abstract A vector of four 8-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_uchar4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_uchar4 uchar4;
-  
-    /*! @abstract A vector of eight 8-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_uchar8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_uchar8 uchar8;
-  
-    /*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_uchar16. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_uchar16 uchar16;
-  
-    /*! @abstract A vector of thirty-two 8-bit unsigned integers with
-     *  relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_uchar32. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_uchar32 uchar32;
-  
-    /*! @abstract A vector of sixty-four 8-bit unsigned integers with
-     *  relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_uchar64. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_uchar64 uchar64;
-  
-    /*! @abstract A vector of two 16-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_short2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_short2 short2;
-  
-    /*! @abstract A vector of four 16-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_short4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_short4 short4;
-  
-    /*! @abstract A vector of eight 16-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_short8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_short8 short8;
-  
-    /*! @abstract A vector of sixteen 16-bit signed (twos-complement)
-     *  integers with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_short16. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_short16 short16;
-  
-    /*! @abstract A vector of thirty-two 16-bit signed (twos-complement)
-     *  integers with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_short32. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_short32 short32;
-  
-    /*! @abstract A vector of two 16-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_ushort2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_ushort2 ushort2;
-  
-    /*! @abstract A vector of four 16-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_ushort4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_ushort4 ushort4;
-  
-    /*! @abstract A vector of eight 16-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_ushort8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_ushort8 ushort8;
-  
-    /*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_ushort16. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_ushort16 ushort16;
-  
-    /*! @abstract A vector of thirty-two 16-bit unsigned integers with
-     *  relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_ushort32. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_ushort32 ushort32;
-  
-    /*! @abstract A vector of two 32-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_int2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_int2 int2;
-  
-    /*! @abstract A vector of four 32-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_int4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_int4 int4;
-  
-    /*! @abstract A vector of eight 32-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_int8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_int8 int8;
-  
-    /*! @abstract A vector of sixteen 32-bit signed (twos-complement)
-     *  integers with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_int16. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_int16 int16;
-  
-    /*! @abstract A vector of two 32-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_uint2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_uint2 uint2;
-  
-    /*! @abstract A vector of four 32-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_uint4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_uint4 uint4;
-  
-    /*! @abstract A vector of eight 32-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_uint8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_uint8 uint8;
-  
-    /*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_uint16. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_uint16 uint16;
-  
-    /*! @abstract A vector of two 32-bit floating-point numbers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_float2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_float2 float2;
-  
-    /*! @abstract A vector of four 32-bit floating-point numbers with
-     *  relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_float4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_float4 float4;
-  
-    /*! @abstract A vector of eight 32-bit floating-point numbers with
-     *  relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_float8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_float8 float8;
-  
-    /*! @abstract A vector of sixteen 32-bit floating-point numbers with
-     *  relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_float16. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_float16 float16;
-  
-    /*! @abstract A vector of two 64-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_long2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_long2 long2;
-  
-    /*! @abstract A vector of four 64-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_long4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_long4 long4;
-  
-    /*! @abstract A vector of eight 64-bit signed (twos-complement) integers
-     *  with relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_long8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_long8 long8;
-  
-    /*! @abstract A vector of two 64-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_ulong2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_ulong2 ulong2;
-  
-    /*! @abstract A vector of four 64-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_ulong4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_ulong4 ulong4;
-  
-    /*! @abstract A vector of eight 64-bit unsigned integers with relaxed
-     *  alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_ulong8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_ulong8 ulong8;
-  
-    /*! @abstract A vector of two 64-bit floating-point numbers with relaxed
-     *  alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_double2. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_double2 double2;
-  
-    /*! @abstract A vector of four 64-bit floating-point numbers with
-     *  relaxed alignment.
-     *  @description In C or Objective-C, this type is available as
-     *  simd_packed_double4. The alignment of this type is only that of the
-     *  underlying scalar element type, so you can use it to load or store
-     *  from an array of that type.                                           */
-typedef ::simd_packed_double4 double4;
-  
-    /*! @abstract A vector of eight 64-bit floating-point numbers with
-     *  relaxed alignment.
-     *  @description This type is not available in Metal. In C or
-     *  Objective-C, this type is available as simd_packed_double8. The
-     *  alignment of this type is only that of the underlying scalar element
-     *  type, so you can use it to load or store from an array of that type.  */
-typedef ::simd_packed_double8 double8;
-  
-  } /* namespace simd::packed::                                               */
-} /* namespace simd::                                                         */
-#endif /* __cplusplus                                                         */
-
-/*  MARK: Deprecated vector types                                             */
-/*! @group Deprecated vector types
- *  @discussion These are the original types used by earlier versions of the
- *  simd library; they are provided here for compatability with existing source
- *  files. Use the new ("simd_"-prefixed) types for future development.       */
-/*! @abstract A vector of two 8-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_char2
- *  or simd::packed_char2 instead.                                            */
-typedef simd_packed_char2 packed_char2;
-
-/*! @abstract A vector of four 8-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_char4
- *  or simd::packed_char4 instead.                                            */
-typedef simd_packed_char4 packed_char4;
-
-/*! @abstract A vector of eight 8-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_char8
- *  or simd::packed_char8 instead.                                            */
-typedef simd_packed_char8 packed_char8;
-
-/*! @abstract A vector of sixteen 8-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_char16
- *  or simd::packed_char16 instead.                                           */
-typedef simd_packed_char16 packed_char16;
-
-/*! @abstract A vector of thirty-two 8-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_char32
- *  or simd::packed_char32 instead.                                           */
-typedef simd_packed_char32 packed_char32;
-
-/*! @abstract A vector of sixty-four 8-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_char64
- *  or simd::packed_char64 instead.                                           */
-typedef simd_packed_char64 packed_char64;
-
-/*! @abstract A vector of two 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uchar2
- *  or simd::packed_uchar2 instead.                                           */
-typedef simd_packed_uchar2 packed_uchar2;
-
-/*! @abstract A vector of four 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uchar4
- *  or simd::packed_uchar4 instead.                                           */
-typedef simd_packed_uchar4 packed_uchar4;
-
-/*! @abstract A vector of eight 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uchar8
- *  or simd::packed_uchar8 instead.                                           */
-typedef simd_packed_uchar8 packed_uchar8;
-
-/*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uchar16
- *  or simd::packed_uchar16 instead.                                          */
-typedef simd_packed_uchar16 packed_uchar16;
-
-/*! @abstract A vector of thirty-two 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uchar32
- *  or simd::packed_uchar32 instead.                                          */
-typedef simd_packed_uchar32 packed_uchar32;
-
-/*! @abstract A vector of sixty-four 8-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uchar64
- *  or simd::packed_uchar64 instead.                                          */
-typedef simd_packed_uchar64 packed_uchar64;
-
-/*! @abstract A vector of two 16-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_short2
- *  or simd::packed_short2 instead.                                           */
-typedef simd_packed_short2 packed_short2;
-
-/*! @abstract A vector of four 16-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_short4
- *  or simd::packed_short4 instead.                                           */
-typedef simd_packed_short4 packed_short4;
-
-/*! @abstract A vector of eight 16-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_short8
- *  or simd::packed_short8 instead.                                           */
-typedef simd_packed_short8 packed_short8;
-
-/*! @abstract A vector of sixteen 16-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_short16
- *  or simd::packed_short16 instead.                                          */
-typedef simd_packed_short16 packed_short16;
-
-/*! @abstract A vector of thirty-two 16-bit signed (twos-complement)
- *  integers with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_short32
- *  or simd::packed_short32 instead.                                          */
-typedef simd_packed_short32 packed_short32;
-
-/*! @abstract A vector of two 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_ushort2
- *  or simd::packed_ushort2 instead.                                          */
-typedef simd_packed_ushort2 packed_ushort2;
-
-/*! @abstract A vector of four 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_ushort4
- *  or simd::packed_ushort4 instead.                                          */
-typedef simd_packed_ushort4 packed_ushort4;
-
-/*! @abstract A vector of eight 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_ushort8
- *  or simd::packed_ushort8 instead.                                          */
-typedef simd_packed_ushort8 packed_ushort8;
-
-/*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use
- *  simd_packed_ushort16 or simd::packed_ushort16 instead.                    */
-typedef simd_packed_ushort16 packed_ushort16;
-
-/*! @abstract A vector of thirty-two 16-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use
- *  simd_packed_ushort32 or simd::packed_ushort32 instead.                    */
-typedef simd_packed_ushort32 packed_ushort32;
-
-/*! @abstract A vector of two 32-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_int2 or
- *  simd::packed_int2 instead.                                                */
-typedef simd_packed_int2 packed_int2;
-
-/*! @abstract A vector of four 32-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_int4 or
- *  simd::packed_int4 instead.                                                */
-typedef simd_packed_int4 packed_int4;
-
-/*! @abstract A vector of eight 32-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_int8 or
- *  simd::packed_int8 instead.                                                */
-typedef simd_packed_int8 packed_int8;
-
-/*! @abstract A vector of sixteen 32-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_int16
- *  or simd::packed_int16 instead.                                            */
-typedef simd_packed_int16 packed_int16;
-
-/*! @abstract A vector of two 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uint2
- *  or simd::packed_uint2 instead.                                            */
-typedef simd_packed_uint2 packed_uint2;
-
-/*! @abstract A vector of four 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uint4
- *  or simd::packed_uint4 instead.                                            */
-typedef simd_packed_uint4 packed_uint4;
-
-/*! @abstract A vector of eight 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uint8
- *  or simd::packed_uint8 instead.                                            */
-typedef simd_packed_uint8 packed_uint8;
-
-/*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_uint16
- *  or simd::packed_uint16 instead.                                           */
-typedef simd_packed_uint16 packed_uint16;
-
-/*! @abstract A vector of two 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_float2
- *  or simd::packed_float2 instead.                                           */
-typedef simd_packed_float2 packed_float2;
-
-/*! @abstract A vector of four 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_float4
- *  or simd::packed_float4 instead.                                           */
-typedef simd_packed_float4 packed_float4;
-
-/*! @abstract A vector of eight 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_float8
- *  or simd::packed_float8 instead.                                           */
-typedef simd_packed_float8 packed_float8;
-
-/*! @abstract A vector of sixteen 32-bit floating-point numbers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_float16
- *  or simd::packed_float16 instead.                                          */
-typedef simd_packed_float16 packed_float16;
-
-/*! @abstract A vector of two 64-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_long2
- *  or simd::packed_long2 instead.                                            */
-typedef simd_packed_long2 packed_long2;
-
-/*! @abstract A vector of four 64-bit signed (twos-complement) integers with
- *  relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_long4
- *  or simd::packed_long4 instead.                                            */
-typedef simd_packed_long4 packed_long4;
-
-/*! @abstract A vector of eight 64-bit signed (twos-complement) integers
- *  with relaxed alignment.
- *  @description This type is deprecated; you should use simd_packed_long8
- *  or simd::packed_long8 instead.                                            */
-typedef simd_packed_long8 packed_long8;
-
-/*! @abstract A vector of two 64-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_ulong2
- *  or simd::packed_ulong2 instead.                                           */
-typedef simd_packed_ulong2 packed_ulong2;
-
-/*! @abstract A vector of four 64-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_ulong4
- *  or simd::packed_ulong4 instead.                                           */
-typedef simd_packed_ulong4 packed_ulong4;
-
-/*! @abstract A vector of eight 64-bit unsigned integers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_ulong8
- *  or simd::packed_ulong8 instead.                                           */
-typedef simd_packed_ulong8 packed_ulong8;
-
-/*! @abstract A vector of two 64-bit floating-point numbers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_double2
- *  or simd::packed_double2 instead.                                          */
-typedef simd_packed_double2 packed_double2;
-
-/*! @abstract A vector of four 64-bit floating-point numbers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_double4
- *  or simd::packed_double4 instead.                                          */
-typedef simd_packed_double4 packed_double4;
-
-/*! @abstract A vector of eight 64-bit floating-point numbers with relaxed
- *  alignment.
- *  @description This type is deprecated; you should use simd_packed_double8
- *  or simd::packed_double8 instead.                                          */
-typedef simd_packed_double8 packed_double8;
-
-# endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */
-#endif
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/simd/quaternion.h b/lib/libc/include/x86_64-macos.10-none/simd/quaternion.h
deleted file mode 100644
index 32158d7e8d..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/simd/quaternion.h
+++ /dev/null
@@ -1,1192 +0,0 @@
-/*! @header
- *  This header defines functions for constructing and using quaternions.
- *  @copyright 2015-2016 Apple, Inc. All rights reserved.
- *  @unsorted                                                                 */
-
-#ifndef SIMD_QUATERNIONS
-#define SIMD_QUATERNIONS
-
-#include <simd/base.h>
-#if SIMD_COMPILER_HAS_REQUIRED_FEATURES
-#include <simd/vector.h>
-#include <simd/types.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-  
-/*  MARK: - C and Objective-C float interfaces                                */
-
-/*! @abstract Constructs a quaternion from four scalar values.
- *
- *  @param ix The first component of the imaginary (vector) part.
- *  @param iy The second component of the imaginary (vector) part.
- *  @param iz The third component of the imaginary (vector) part.
- *
- *  @param r The real (scalar) part.                                          */
-static inline SIMD_CFUNC simd_quatf simd_quaternion(float ix, float iy, float iz, float r) {
-  return (simd_quatf){ { ix, iy, iz, r } };
-}
-  
-/*! @abstract Constructs a quaternion from an array of four scalars.
- *
- *  @discussion Note that the imaginary part of the quaternion comes from 
- *  array elements 0, 1, and 2, and the real part comes from element 3.       */
-static inline SIMD_NONCONST simd_quatf simd_quaternion(const float xyzr[4]) {
-  return (simd_quatf){ *(const simd_packed_float4 *)xyzr };
-}
-  
-/*! @abstract Constructs a quaternion from a four-element vector.
- *
- *  @discussion Note that the imaginary (vector) part of the quaternion comes
- *  from lanes 0, 1, and 2 of the vector, and the real (scalar) part comes from
- *  lane 3.                                                                   */
-static inline SIMD_CFUNC simd_quatf simd_quaternion(simd_float4 xyzr) {
-  return (simd_quatf){ xyzr };
-}
-  
-/*! @abstract Constructs a quaternion that rotates by `angle` radians about
- *  `axis`.                                                                   */
-static inline SIMD_CFUNC simd_quatf simd_quaternion(float angle, simd_float3 axis);
-  
-/*! @abstract Construct a quaternion that rotates from one vector to another.
- *
- *  @param from A normalized three-element vector.
- *  @param to A normalized three-element vector.
- *
- *  @discussion The rotation axis is `simd_cross(from, to)`. If `from` and
- *  `to` point in opposite directions (to within machine precision), an
- *  arbitrary rotation axis is chosen, and the angle is pi radians.           */
-static SIMD_NOINLINE simd_quatf simd_quaternion(simd_float3 from, simd_float3 to);
-
-/*! @abstract Construct a quaternion from a 3x3 rotation `matrix`.
- *
- *  @discussion If `matrix` is not orthogonal with determinant 1, the result
- *  is undefined.                                                             */
-static SIMD_NOINLINE simd_quatf simd_quaternion(simd_float3x3 matrix);
-
-/*! @abstract Construct a quaternion from a 4x4 rotation `matrix`.
- *
- *  @discussion The last row and column of the matrix are ignored. This
- *  function is equivalent to calling simd_quaternion with the upper-left 3x3
- *  submatrix                .                                                */
-static SIMD_NOINLINE simd_quatf simd_quaternion(simd_float4x4 matrix);
-  
-/*! @abstract The real (scalar) part of the quaternion `q`.                   */
-static inline SIMD_CFUNC float simd_real(simd_quatf q) {
-  return q.vector.w;
-}
-  
-/*! @abstract The imaginary (vector) part of the quaternion `q`.              */
-static inline SIMD_CFUNC simd_float3 simd_imag(simd_quatf q) {
-  return q.vector.xyz;
-}
-  
-/*! @abstract The angle (in radians) of rotation represented by `q`.          */
-static inline SIMD_CFUNC float simd_angle(simd_quatf q);
-  
-/*! @abstract The normalized axis (a 3-element vector) around which the
- *  action of the quaternion `q` rotates.                                     */
-static inline SIMD_CFUNC simd_float3 simd_axis(simd_quatf q);
-  
-/*! @abstract The sum of the quaternions `p` and `q`.                         */
-static inline SIMD_CFUNC simd_quatf simd_add(simd_quatf p, simd_quatf q);
-  
-/*! @abstract The difference of the quaternions `p` and `q`.                  */
-static inline SIMD_CFUNC simd_quatf simd_sub(simd_quatf p, simd_quatf q);
-  
-/*! @abstract The product of the quaternions `p` and `q`.                     */
-static inline SIMD_CFUNC simd_quatf simd_mul(simd_quatf p, simd_quatf q);
-  
-/*! @abstract The quaternion `q` scaled by the real value `a`.                */
-static inline SIMD_CFUNC simd_quatf simd_mul(simd_quatf q, float a);
-  
-/*! @abstract The quaternion `q` scaled by the real value `a`.                */
-static inline SIMD_CFUNC simd_quatf simd_mul(float a, simd_quatf q);
-  
-/*! @abstract The conjugate of the quaternion `q`.                            */
-static inline SIMD_CFUNC simd_quatf simd_conjugate(simd_quatf q);
-  
-/*! @abstract The (multiplicative) inverse of the quaternion `q`.             */
-static inline SIMD_CFUNC simd_quatf simd_inverse(simd_quatf q);
-  
-/*! @abstract The negation (additive inverse) of the quaternion `q`.          */
-static inline SIMD_CFUNC simd_quatf simd_negate(simd_quatf q);
-  
-/*! @abstract The dot product of the quaternions `p` and `q` interpreted as
- *  four-dimensional vectors.                                                 */
-static inline SIMD_CFUNC float simd_dot(simd_quatf p, simd_quatf q);
-  
-/*! @abstract The length of the quaternion `q`.                               */
-static inline SIMD_CFUNC float simd_length(simd_quatf q);
-  
-/*! @abstract The unit quaternion obtained by normalizing `q`.                */
-static inline SIMD_CFUNC simd_quatf simd_normalize(simd_quatf q);
-  
-/*! @abstract Rotates the vector `v` by the quaternion `q`.                   */
-static inline SIMD_CFUNC simd_float3 simd_act(simd_quatf q, simd_float3 v);
-  
-/*! @abstract Logarithm of the quaternion `q`.
- *  @discussion Do not call this function directly; use `log(q)` instead.
- *
- *  We can write a quaternion `q` in the form: `r(cos(t) + sin(t)v)` where
- *  `r` is the length of `q`, `t` is an angle, and `v` is a unit 3-vector.
- *  The logarithm of `q` is `log(r) + tv`, just like the logarithm of the
- *  complex number `r*(cos(t) + i sin(t))` is `log(r) + it`.
- *
- *  Note that this function is not robust against poorly-scaled non-unit
- *  quaternions, because it is primarily used for spline interpolation of
- *  unit quaternions. If you need to compute a robust logarithm of general
- *  quaternions, you can use the following approach:
- *
- *    scale = simd_reduce_max(simd_abs(q.vector));
- *    logq = log(simd_recip(scale)*q);
- *    logq.real += log(scale);
- *    return logq;                                                            */
-static SIMD_NOINLINE simd_quatf __tg_log(simd_quatf q);
-    
-/*! @abstract Inverse of `log( )`; the exponential map on quaternions.
- *  @discussion Do not call this function directly; use `exp(q)` instead.     */
-static SIMD_NOINLINE simd_quatf __tg_exp(simd_quatf q);
-  
-/*! @abstract Spherical linear interpolation along the shortest arc between
- *  quaternions `q0` and `q1`.                                                */
-static SIMD_NOINLINE simd_quatf simd_slerp(simd_quatf q0, simd_quatf q1, float t);
-
-/*! @abstract Spherical linear interpolation along the longest arc between
- *  quaternions `q0` and `q1`.                                                */
-static SIMD_NOINLINE simd_quatf simd_slerp_longest(simd_quatf q0, simd_quatf q1, float t);
-
-/*! @abstract Interpolate between quaternions along a spherical cubic spline.
- *
- *  @discussion The function interpolates between q1 and q2. q0 is the left
- *  endpoint of the previous interval, and q3 is the right endpoint of the next
- *  interval. Use this function to smoothly interpolate between a sequence of
- *  rotations.                                                                */
-static SIMD_NOINLINE simd_quatf simd_spline(simd_quatf q0, simd_quatf q1, simd_quatf q2, simd_quatf q3, float t);
-
-/*! @abstract Spherical cubic Bezier interpolation between quaternions.
- *
- *  @discussion The function treats q0 ... q3 as control points and uses slerp
- *  in place of lerp in the De Castlejeau algorithm. The endpoints of
- *  interpolation are thus q0 and q3, and the curve will not generally pass
- *  through q1 or q2. Note that the convex hull property of "standard" Bezier
- *  curve does not hold on the sphere.                                        */
-static SIMD_NOINLINE simd_quatf simd_bezier(simd_quatf q0, simd_quatf q1, simd_quatf q2, simd_quatf q3, float t);
-  
-#ifdef __cplusplus
-} /* extern "C" */
-/*  MARK: - C++ float interfaces                                              */
-
-namespace simd {
-  struct quatf : ::simd_quatf {
-    /*! @abstract The identity quaternion.                                    */
-    quatf( ) : ::simd_quatf(::simd_quaternion((float4){0,0,0,1})) { }
-    
-    /*! @abstract Constructs a C++ quaternion from a C quaternion.            */
-    quatf(::simd_quatf q) : ::simd_quatf(q) { }
-    
-    /*! @abstract Constructs a quaternion from components.                    */
-    quatf(float ix, float iy, float iz, float r) : ::simd_quatf(::simd_quaternion(ix, iy, iz, r)) { }
-    
-    /*! @abstract Constructs a quaternion from an array of scalars.           */
-    quatf(const float xyzr[4]) : ::simd_quatf(::simd_quaternion(xyzr)) { }
-    
-    /*! @abstract Constructs a quaternion from a vector.                      */
-    quatf(float4 xyzr) : ::simd_quatf(::simd_quaternion(xyzr)) { }
-    
-    /*! @abstract Quaternion representing rotation about `axis` by `angle` 
-     *  radians.                                                              */
-    quatf(float angle, float3 axis) : ::simd_quatf(::simd_quaternion(angle, axis)) { }
-    
-    /*! @abstract Quaternion that rotates `from` into `to`.                   */
-    quatf(float3 from, float3 to) : ::simd_quatf(::simd_quaternion(from, to)) { }
-    
-    /*! @abstract Constructs a quaternion from a rotation matrix.             */
-    quatf(::simd_float3x3 matrix) : ::simd_quatf(::simd_quaternion(matrix)) { }
-    
-    /*! @abstract Constructs a quaternion from a rotation matrix.             */
-    quatf(::simd_float4x4 matrix) : ::simd_quatf(::simd_quaternion(matrix)) { }
-  
-    /*! @abstract The real (scalar) part of the quaternion.                   */
-    float real(void) const { return ::simd_real(*this); }
-    
-    /*! @abstract The imaginary (vector) part of the quaternion.              */
-    float3 imag(void) const { return ::simd_imag(*this); }
-    
-    /*! @abstract The angle the quaternion rotates by.                        */
-    float angle(void) const { return ::simd_angle(*this); }
-    
-    /*! @abstract The axis the quaternion rotates about.                      */
-    float3 axis(void) const { return ::simd_axis(*this); }
-    
-    /*! @abstract The length of the quaternion.                               */
-    float length(void) const { return ::simd_length(*this); }
-    
-    /*! @abstract Act on the vector `v` by rotation.                          */
-    float3  operator()(const ::simd_float3 v) const { return ::simd_act(*this, v); }
-  };
-  
-  static SIMD_CPPFUNC quatf operator+(const ::simd_quatf p, const ::simd_quatf q) { return ::simd_add(p, q); }
-  static SIMD_CPPFUNC quatf operator-(const ::simd_quatf p, const ::simd_quatf q) { return ::simd_sub(p, q); }
-  static SIMD_CPPFUNC quatf operator-(const ::simd_quatf p) { return ::simd_negate(p); }
-  static SIMD_CPPFUNC quatf operator*(const float r, const ::simd_quatf p) { return ::simd_mul(r, p); }
-  static SIMD_CPPFUNC quatf operator*(const ::simd_quatf p, const float r) { return ::simd_mul(p, r); }
-  static SIMD_CPPFUNC quatf operator*(const ::simd_quatf p, const ::simd_quatf q) { return ::simd_mul(p, q); }
-  static SIMD_CPPFUNC quatf operator/(const ::simd_quatf p, const ::simd_quatf q) { return ::simd_mul(p, ::simd_inverse(q)); }
-  static SIMD_CPPFUNC quatf operator+=(quatf &p, const ::simd_quatf q) { return p = p+q; }
-  static SIMD_CPPFUNC quatf operator-=(quatf &p, const ::simd_quatf q) { return p = p-q; }
-  static SIMD_CPPFUNC quatf operator*=(quatf &p, const float r) { return p = p*r; }
-  static SIMD_CPPFUNC quatf operator*=(quatf &p, const ::simd_quatf q) { return p = p*q; }
-  static SIMD_CPPFUNC quatf operator/=(quatf &p, const ::simd_quatf q) { return p = p/q; }
-  
-  /*! @abstract The conjugate of the quaternion `q`.                          */
-  static SIMD_CPPFUNC quatf conjugate(const ::simd_quatf p) { return ::simd_conjugate(p); }
-  
-  /*! @abstract The (multiplicative) inverse of the quaternion `q`.           */
-  static SIMD_CPPFUNC quatf inverse(const ::simd_quatf p) { return ::simd_inverse(p); }
-
-  /*! @abstract The dot product of the quaternions `p` and `q` interpreted as
-   *  four-dimensional vectors.                                               */
-  static SIMD_CPPFUNC float dot(const ::simd_quatf p, const ::simd_quatf q) { return ::simd_dot(p, q); }
-  
-  /*! @abstract The unit quaternion obtained by normalizing `q`.              */
-  static SIMD_CPPFUNC quatf normalize(const ::simd_quatf p) { return ::simd_normalize(p); }
-
-  /*! @abstract logarithm of the quaternion `q`.                              */
-  static SIMD_CPPFUNC quatf log(const ::simd_quatf q) { return ::__tg_log(q); }
-
-  /*! @abstract exponential map of quaterion `q`.                             */
-  static SIMD_CPPFUNC quatf exp(const ::simd_quatf q) { return ::__tg_exp(q); }
-  
-  /*! @abstract Spherical linear interpolation along the shortest arc between
-   *  quaternions `q0` and `q1`.                                              */
-  static SIMD_CPPFUNC quatf slerp(const ::simd_quatf p0, const ::simd_quatf p1, float t) { return ::simd_slerp(p0, p1, t); }
-  
-  /*! @abstract Spherical linear interpolation along the longest arc between
-   *  quaternions `q0` and `q1`.                                              */
-  static SIMD_CPPFUNC quatf slerp_longest(const ::simd_quatf p0, const ::simd_quatf p1, float t) { return ::simd_slerp_longest(p0, p1, t); }
-  
-  /*! @abstract Interpolate between quaternions along a spherical cubic spline.
-   *
-   *  @discussion The function interpolates between q1 and q2. q0 is the left
-   *  endpoint of the previous interval, and q3 is the right endpoint of the next
-   *  interval. Use this function to smoothly interpolate between a sequence of
-   *  rotations.                                                              */
-  static SIMD_CPPFUNC quatf spline(const ::simd_quatf p0, const ::simd_quatf p1, const ::simd_quatf p2, const ::simd_quatf p3, float t) { return ::simd_spline(p0, p1, p2, p3, t); }
-  
-  /*! @abstract Spherical cubic Bezier interpolation between quaternions.
-   *
-   *  @discussion The function treats q0 ... q3 as control points and uses slerp
-   *  in place of lerp in the De Castlejeau algorithm. The endpoints of
-   *  interpolation are thus q0 and q3, and the curve will not generally pass
-   *  through q1 or q2. Note that the convex hull property of "standard" Bezier
-   *  curve does not hold on the sphere.                                      */
-  static SIMD_CPPFUNC quatf bezier(const ::simd_quatf p0, const ::simd_quatf p1, const ::simd_quatf p2, const ::simd_quatf p3, float t) { return ::simd_bezier(p0, p1, p2, p3, t); }
-}
-
-extern "C" {
-#endif /* __cplusplus */
-  
-/*  MARK: - float implementations                                             */
-
-#include <simd/math.h>
-#include <simd/geometry.h>
-  
-/*  tg_promote is implementation gobbledygook that enables the compile-time
- *  dispatching in tgmath.h to work its magic.                                */
-static simd_quatf __attribute__((__overloadable__)) __tg_promote(simd_quatf);
-  
-/*! @abstract Constructs a quaternion from imaginary and real parts.
- *  @discussion This function is hidden behind an underscore to avoid confusion
- *  with the angle-axis constructor.                                          */
-static inline SIMD_CFUNC simd_quatf _simd_quaternion(simd_float3 imag, float real) {
-  return simd_quaternion(simd_make_float4(imag, real));
-}
-  
-static inline SIMD_CFUNC simd_quatf simd_quaternion(float angle, simd_float3 axis) {
-  return _simd_quaternion(sin(angle/2) * axis, cos(angle/2));
-}
-  
-static inline SIMD_CFUNC float simd_angle(simd_quatf q) {
-  return 2*atan2(simd_length(q.vector.xyz), q.vector.w);
-}
-  
-static inline SIMD_CFUNC simd_float3 simd_axis(simd_quatf q) {
-  return simd_normalize(q.vector.xyz);
-}
-  
-static inline SIMD_CFUNC simd_quatf simd_add(simd_quatf p, simd_quatf q) {
-  return simd_quaternion(p.vector + q.vector);
-}
-  
-static inline SIMD_CFUNC simd_quatf simd_sub(simd_quatf p, simd_quatf q) {
-  return simd_quaternion(p.vector - q.vector);
-}
-
-static inline SIMD_CFUNC simd_quatf simd_mul(simd_quatf p, simd_quatf q) {
-  #pragma STDC FP_CONTRACT ON
-  return simd_quaternion((p.vector.x * __builtin_shufflevector(q.vector, -q.vector, 3,6,1,4) +
-                          p.vector.y * __builtin_shufflevector(q.vector, -q.vector, 2,3,4,5)) +
-                         (p.vector.z * __builtin_shufflevector(q.vector, -q.vector, 5,0,3,6) +
-                          p.vector.w * q.vector));
-}
-
-static inline SIMD_CFUNC simd_quatf simd_mul(simd_quatf q, float a) {
-  return simd_quaternion(a * q.vector);
-}
-
-static inline SIMD_CFUNC simd_quatf simd_mul(float a, simd_quatf q) {
-  return simd_mul(q,a);
-}
-  
-static inline SIMD_CFUNC simd_quatf simd_conjugate(simd_quatf q) {
-  return simd_quaternion(q.vector * (simd_float4){-1,-1,-1, 1});
-}
-  
-static inline SIMD_CFUNC simd_quatf simd_inverse(simd_quatf q) {
-  return simd_quaternion(simd_conjugate(q).vector * simd_recip(simd_length_squared(q.vector)));
-}
-  
-static inline SIMD_CFUNC simd_quatf simd_negate(simd_quatf q) {
-  return simd_quaternion(-q.vector);
-}
-  
-static inline SIMD_CFUNC float simd_dot(simd_quatf p, simd_quatf q) {
-  return simd_dot(p.vector, q.vector);
-}
-  
-static inline SIMD_CFUNC float simd_length(simd_quatf q) {
-  return simd_length(q.vector);
-}
-  
-static inline SIMD_CFUNC simd_quatf simd_normalize(simd_quatf q) {
-  float length_squared = simd_length_squared(q.vector);
-  if (length_squared == 0) {
-    return simd_quaternion((simd_float4){0,0,0,1});
-  }
-  return simd_quaternion(q.vector * simd_rsqrt(length_squared));
-}
-
-#if defined __arm__ || defined __arm64__
-/*! @abstract Multiplies the vector `v` by the quaternion `q`.
- *  
- *  @discussion This IS NOT the action of `q` on `v` (i.e. this is not rotation
- *  by `q`. That operation is provided by `simd_act(q, v)`. This function is an
- *  implementation detail and you should not call it directly. It may be
- *  removed or modified in future versions of the simd module.                */
-static inline SIMD_CFUNC simd_quatf _simd_mul_vq(simd_float3 v, simd_quatf q) {
-  #pragma STDC FP_CONTRACT ON
-  return simd_quaternion(v.x * __builtin_shufflevector(q.vector, -q.vector, 3,6,1,4) +
-                         v.y * __builtin_shufflevector(q.vector, -q.vector, 2,3,4,5) +
-                         v.z * __builtin_shufflevector(q.vector, -q.vector, 5,0,3,6));
-}
-#endif
-  
-static inline SIMD_CFUNC simd_float3 simd_act(simd_quatf q, simd_float3 v) {
-#if defined __arm__ || defined __arm64__
-  return simd_mul(q, _simd_mul_vq(v, simd_conjugate(q))).vector.xyz;
-#else
-  #pragma STDC FP_CONTRACT ON
-  simd_float3 t = 2*simd_cross(simd_imag(q),v);
-  return v + simd_real(q)*t + simd_cross(simd_imag(q), t);
-#endif
-}
-
-static SIMD_NOINLINE simd_quatf __tg_log(simd_quatf q) {
-  float real = __tg_log(simd_length_squared(q.vector))/2;
-  if (simd_equal(simd_imag(q), 0)) return _simd_quaternion(0, real);
-  simd_float3 imag = __tg_acos(simd_real(q)/simd_length(q)) * simd_normalize(simd_imag(q));
-  return _simd_quaternion(imag, real);
-}
-  
-static SIMD_NOINLINE simd_quatf __tg_exp(simd_quatf q) {
-  //  angle is actually *twice* the angle of the rotation corresponding to
-  //  the resulting quaternion, which is why we don't simply use the (angle,
-  //  axis) constructor to generate `unit`.
-  float angle = simd_length(simd_imag(q));
-  if (angle == 0) return _simd_quaternion(0, exp(simd_real(q)));
-  simd_float3 axis = simd_normalize(simd_imag(q));
-  simd_quatf unit = _simd_quaternion(sin(angle)*axis, cosf(angle));
-  return simd_mul(exp(simd_real(q)), unit);
-}
- 
-/*! @abstract Implementation detail of the `simd_quaternion(from, to)`
- *  initializer.
- *
- *  @discussion Computes the quaternion rotation `from` to `to` if they are
- *  separated by less than 90 degrees. Not numerically stable for larger
- *  angles. This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static inline SIMD_CFUNC simd_quatf _simd_quaternion_reduced(simd_float3 from, simd_float3 to) {
-  simd_float3 half = simd_normalize(from + to);
-  return _simd_quaternion(simd_cross(from, half), simd_dot(from, half));
-}
-
-static SIMD_NOINLINE simd_quatf simd_quaternion(simd_float3 from, simd_float3 to) {
-  
-  //  If the angle between from and to is not too big, we can compute the
-  //  rotation accurately using a simple implementation.
-  if (simd_dot(from, to) >= 0) {
-    return _simd_quaternion_reduced(from, to);
-  }
-  
-  //  Because from and to are more than 90 degrees apart, we compute the
-  //  rotation in two stages (from -> half), (half -> to) to preserve numerical
-  //  accuracy.
-  simd_float3 half = simd_normalize(from + to);
-  
-  if (simd_length_squared(half) == 0) {
-    //  half is nearly zero, so from and to point in nearly opposite directions
-    //  and the rotation is numerically underspecified. Pick an axis orthogonal
-    //  to the vectors, and use an angle of pi radians.
-    simd_float3 abs_from = simd_abs(from);
-    if (abs_from.x <= abs_from.y && abs_from.x <= abs_from.z)
-      return _simd_quaternion(simd_normalize(simd_cross(from, (simd_float3){1,0,0})), 0.f);
-    else if (abs_from.y <= abs_from.z)
-      return _simd_quaternion(simd_normalize(simd_cross(from, (simd_float3){0,1,0})), 0.f);
-    else
-      return _simd_quaternion(simd_normalize(simd_cross(from, (simd_float3){0,0,1})), 0.f);
-  }
-  
-  //  Compute the two-step rotation.                         */
-  return simd_mul(_simd_quaternion_reduced(from, half),
-                  _simd_quaternion_reduced(half, to));
-}
-
-static SIMD_NOINLINE simd_quatf simd_quaternion(simd_float3x3 matrix) {
-  const simd_float3 *mat = matrix.columns;
-  float trace = mat[0][0] + mat[1][1] + mat[2][2];
-  if (trace >= 0.0) {
-    float r = 2*sqrt(1 + trace);
-    float rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[1][2] - mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]),
-                           rinv*(mat[0][1] - mat[1][0]),
-                           r/4);
-  } else if (mat[0][0] >= mat[1][1] && mat[0][0] >= mat[2][2]) {
-    float r = 2*sqrt(1 - mat[1][1] - mat[2][2] + mat[0][0]);
-    float rinv = simd_recip(r);
-    return simd_quaternion(r/4,
-                           rinv*(mat[0][1] + mat[1][0]),
-                           rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] - mat[2][1]));
-  } else if (mat[1][1] >= mat[2][2]) {
-    float r = 2*sqrt(1 - mat[0][0] - mat[2][2] + mat[1][1]);
-    float rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][1] + mat[1][0]),
-                           r/4,
-                           rinv*(mat[1][2] + mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]));
-  } else {
-    float r = 2*sqrt(1 - mat[0][0] - mat[1][1] + mat[2][2]);
-    float rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] + mat[2][1]),
-                           r/4,
-                           rinv*(mat[0][1] - mat[1][0]));
-  }
-}
-  
-static SIMD_NOINLINE simd_quatf simd_quaternion(simd_float4x4 matrix) {
-  const simd_float4 *mat = matrix.columns;
-  float trace = mat[0][0] + mat[1][1] + mat[2][2];
-  if (trace >= 0.0) {
-    float r = 2*sqrt(1 + trace);
-    float rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[1][2] - mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]),
-                           rinv*(mat[0][1] - mat[1][0]),
-                           r/4);
-  } else if (mat[0][0] >= mat[1][1] && mat[0][0] >= mat[2][2]) {
-    float r = 2*sqrt(1 - mat[1][1] - mat[2][2] + mat[0][0]);
-    float rinv = simd_recip(r);
-    return simd_quaternion(r/4,
-                           rinv*(mat[0][1] + mat[1][0]),
-                           rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] - mat[2][1]));
-  } else if (mat[1][1] >= mat[2][2]) {
-    float r = 2*sqrt(1 - mat[0][0] - mat[2][2] + mat[1][1]);
-    float rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][1] + mat[1][0]),
-                           r/4,
-                           rinv*(mat[1][2] + mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]));
-  } else {
-    float r = 2*sqrt(1 - mat[0][0] - mat[1][1] + mat[2][2]);
-    float rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] + mat[2][1]),
-                           r/4,
-                           rinv*(mat[0][1] - mat[1][0]));
-  }
-}
-  
-/*! @abstract The angle between p and q interpreted as 4-dimensional vectors.
- *
- *  @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_NOINLINE float _simd_angle(simd_quatf p, simd_quatf q) {
-  return 2*atan2(simd_length(p.vector - q.vector), simd_length(p.vector + q.vector));
-}
-  
-/*! @abstract sin(x)/x.
- *
- *  @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_CFUNC float _simd_sinc(float x) {
-  if (x == 0) return 1;
-  return sin(x)/x;
-}
- 
-/*! @abstract Spherical lerp between q0 and q1.
- *
- *  @discussion This function may interpolate along either the longer or
- *  shorter path between q0 and q1; it is used as an implementation detail
- *  in `simd_slerp` and `simd_slerp_longest`; you should use those functions
- *  instead of calling this directly.                                         */
-static SIMD_NOINLINE simd_quatf _simd_slerp_internal(simd_quatf q0, simd_quatf q1, float t) {
-  float s = 1 - t;
-  float a = _simd_angle(q0, q1);
-  float r = simd_recip(_simd_sinc(a));
-  return simd_normalize(simd_quaternion(_simd_sinc(s*a)*r*s*q0.vector + _simd_sinc(t*a)*r*t*q1.vector));
-}
-  
-static SIMD_NOINLINE simd_quatf simd_slerp(simd_quatf q0, simd_quatf q1, float t) {
-  if (simd_dot(q0, q1) >= 0)
-    return _simd_slerp_internal(q0, q1, t);
-  return _simd_slerp_internal(q0, simd_negate(q1), t);
-}
-
-static SIMD_NOINLINE simd_quatf simd_slerp_longest(simd_quatf q0, simd_quatf q1, float t) {
-  if (simd_dot(q0, q1) >= 0)
-    return _simd_slerp_internal(q0, simd_negate(q1), t);
-  return _simd_slerp_internal(q0, q1, t);
-}
-  
-/*! @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_NOINLINE simd_quatf _simd_intermediate(simd_quatf q0, simd_quatf q1, simd_quatf q2) {
-  simd_quatf p0 = __tg_log(simd_mul(q0, simd_inverse(q1)));
-  simd_quatf p2 = __tg_log(simd_mul(q2, simd_inverse(q1)));
-  return simd_normalize(simd_mul(q1, __tg_exp(simd_mul(-0.25, simd_add(p0,p2)))));
-}
-
-/*! @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_NOINLINE simd_quatf _simd_squad(simd_quatf q0, simd_quatf qa, simd_quatf qb, simd_quatf q1, float t) {
-  simd_quatf r0 = _simd_slerp_internal(q0, q1, t);
-  simd_quatf r1 = _simd_slerp_internal(qa, qb, t);
-  return _simd_slerp_internal(r0, r1, 2*t*(1 - t));
-}
-  
-static SIMD_NOINLINE simd_quatf simd_spline(simd_quatf q0, simd_quatf q1, simd_quatf q2, simd_quatf q3, float t) {
-  simd_quatf qa = _simd_intermediate(q0, q1, q2);
-  simd_quatf qb = _simd_intermediate(q1, q2, q3);
-  return _simd_squad(q1, qa, qb, q2, t);
-}
-  
-static SIMD_NOINLINE simd_quatf simd_bezier(simd_quatf q0, simd_quatf q1, simd_quatf q2, simd_quatf q3, float t) {
-  simd_quatf q01 = _simd_slerp_internal(q0, q1, t);
-  simd_quatf q12 = _simd_slerp_internal(q1, q2, t);
-  simd_quatf q23 = _simd_slerp_internal(q2, q3, t);
-  simd_quatf q012 = _simd_slerp_internal(q01, q12, t);
-  simd_quatf q123 = _simd_slerp_internal(q12, q23, t);
-  return _simd_slerp_internal(q012, q123, t);
-}
-
-/*  MARK: - C and Objective-C double interfaces                                */
-
-/*! @abstract Constructs a quaternion from four scalar values.
- *
- *  @param ix The first component of the imaginary (vector) part.
- *  @param iy The second component of the imaginary (vector) part.
- *  @param iz The third component of the imaginary (vector) part.
- *
- *  @param r The real (scalar) part.                                          */
-static inline SIMD_CFUNC simd_quatd simd_quaternion(double ix, double iy, double iz, double r) {
-  return (simd_quatd){ { ix, iy, iz, r } };
-}
-  
-/*! @abstract Constructs a quaternion from an array of four scalars.
- *
- *  @discussion Note that the imaginary part of the quaternion comes from 
- *  array elements 0, 1, and 2, and the real part comes from element 3.       */
-static inline SIMD_NONCONST simd_quatd simd_quaternion(const double xyzr[4]) {
-  return (simd_quatd){ *(const simd_packed_double4 *)xyzr };
-}
-  
-/*! @abstract Constructs a quaternion from a four-element vector.
- *
- *  @discussion Note that the imaginary (vector) part of the quaternion comes
- *  from lanes 0, 1, and 2 of the vector, and the real (scalar) part comes from
- *  lane 3.                                                                   */
-static inline SIMD_CFUNC simd_quatd simd_quaternion(simd_double4 xyzr) {
-  return (simd_quatd){ xyzr };
-}
-  
-/*! @abstract Constructs a quaternion that rotates by `angle` radians about
- *  `axis`.                                                                   */
-static inline SIMD_CFUNC simd_quatd simd_quaternion(double angle, simd_double3 axis);
-  
-/*! @abstract Construct a quaternion that rotates from one vector to another.
- *
- *  @param from A normalized three-element vector.
- *  @param to A normalized three-element vector.
- *
- *  @discussion The rotation axis is `simd_cross(from, to)`. If `from` and
- *  `to` point in opposite directions (to within machine precision), an
- *  arbitrary rotation axis is chosen, and the angle is pi radians.           */
-static SIMD_NOINLINE simd_quatd simd_quaternion(simd_double3 from, simd_double3 to);
-
-/*! @abstract Construct a quaternion from a 3x3 rotation `matrix`.
- *
- *  @discussion If `matrix` is not orthogonal with determinant 1, the result
- *  is undefined.                                                             */
-static SIMD_NOINLINE simd_quatd simd_quaternion(simd_double3x3 matrix);
-
-/*! @abstract Construct a quaternion from a 4x4 rotation `matrix`.
- *
- *  @discussion The last row and column of the matrix are ignored. This
- *  function is equivalent to calling simd_quaternion with the upper-left 3x3
- *  submatrix                .                                                */
-static SIMD_NOINLINE simd_quatd simd_quaternion(simd_double4x4 matrix);
-  
-/*! @abstract The real (scalar) part of the quaternion `q`.                   */
-static inline SIMD_CFUNC double simd_real(simd_quatd q) {
-  return q.vector.w;
-}
-  
-/*! @abstract The imaginary (vector) part of the quaternion `q`.              */
-static inline SIMD_CFUNC simd_double3 simd_imag(simd_quatd q) {
-  return q.vector.xyz;
-}
-  
-/*! @abstract The angle (in radians) of rotation represented by `q`.          */
-static inline SIMD_CFUNC double simd_angle(simd_quatd q);
-  
-/*! @abstract The normalized axis (a 3-element vector) around which the
- *  action of the quaternion `q` rotates.                                     */
-static inline SIMD_CFUNC simd_double3 simd_axis(simd_quatd q);
-  
-/*! @abstract The sum of the quaternions `p` and `q`.                         */
-static inline SIMD_CFUNC simd_quatd simd_add(simd_quatd p, simd_quatd q);
-  
-/*! @abstract The difference of the quaternions `p` and `q`.                  */
-static inline SIMD_CFUNC simd_quatd simd_sub(simd_quatd p, simd_quatd q);
-  
-/*! @abstract The product of the quaternions `p` and `q`.                     */
-static inline SIMD_CFUNC simd_quatd simd_mul(simd_quatd p, simd_quatd q);
-  
-/*! @abstract The quaternion `q` scaled by the real value `a`.                */
-static inline SIMD_CFUNC simd_quatd simd_mul(simd_quatd q, double a);
-  
-/*! @abstract The quaternion `q` scaled by the real value `a`.                */
-static inline SIMD_CFUNC simd_quatd simd_mul(double a, simd_quatd q);
-  
-/*! @abstract The conjugate of the quaternion `q`.                            */
-static inline SIMD_CFUNC simd_quatd simd_conjugate(simd_quatd q);
-  
-/*! @abstract The (multiplicative) inverse of the quaternion `q`.             */
-static inline SIMD_CFUNC simd_quatd simd_inverse(simd_quatd q);
-  
-/*! @abstract The negation (additive inverse) of the quaternion `q`.          */
-static inline SIMD_CFUNC simd_quatd simd_negate(simd_quatd q);
-  
-/*! @abstract The dot product of the quaternions `p` and `q` interpreted as
- *  four-dimensional vectors.                                                 */
-static inline SIMD_CFUNC double simd_dot(simd_quatd p, simd_quatd q);
-  
-/*! @abstract The length of the quaternion `q`.                               */
-static inline SIMD_CFUNC double simd_length(simd_quatd q);
-  
-/*! @abstract The unit quaternion obtained by normalizing `q`.                */
-static inline SIMD_CFUNC simd_quatd simd_normalize(simd_quatd q);
-  
-/*! @abstract Rotates the vector `v` by the quaternion `q`.                   */
-static inline SIMD_CFUNC simd_double3 simd_act(simd_quatd q, simd_double3 v);
-  
-/*! @abstract Logarithm of the quaternion `q`.
- *  @discussion Do not call this function directly; use `log(q)` instead.
- *
- *  We can write a quaternion `q` in the form: `r(cos(t) + sin(t)v)` where
- *  `r` is the length of `q`, `t` is an angle, and `v` is a unit 3-vector.
- *  The logarithm of `q` is `log(r) + tv`, just like the logarithm of the
- *  complex number `r*(cos(t) + i sin(t))` is `log(r) + it`.
- *
- *  Note that this function is not robust against poorly-scaled non-unit
- *  quaternions, because it is primarily used for spline interpolation of
- *  unit quaternions. If you need to compute a robust logarithm of general
- *  quaternions, you can use the following approach:
- *
- *    scale = simd_reduce_max(simd_abs(q.vector));
- *    logq = log(simd_recip(scale)*q);
- *    logq.real += log(scale);
- *    return logq;                                                            */
-static SIMD_NOINLINE simd_quatd __tg_log(simd_quatd q);
-    
-/*! @abstract Inverse of `log( )`; the exponential map on quaternions.
- *  @discussion Do not call this function directly; use `exp(q)` instead.     */
-static SIMD_NOINLINE simd_quatd __tg_exp(simd_quatd q);
-  
-/*! @abstract Spherical linear interpolation along the shortest arc between
- *  quaternions `q0` and `q1`.                                                */
-static SIMD_NOINLINE simd_quatd simd_slerp(simd_quatd q0, simd_quatd q1, double t);
-
-/*! @abstract Spherical linear interpolation along the longest arc between
- *  quaternions `q0` and `q1`.                                                */
-static SIMD_NOINLINE simd_quatd simd_slerp_longest(simd_quatd q0, simd_quatd q1, double t);
-
-/*! @abstract Interpolate between quaternions along a spherical cubic spline.
- *
- *  @discussion The function interpolates between q1 and q2. q0 is the left
- *  endpoint of the previous interval, and q3 is the right endpoint of the next
- *  interval. Use this function to smoothly interpolate between a sequence of
- *  rotations.                                                                */
-static SIMD_NOINLINE simd_quatd simd_spline(simd_quatd q0, simd_quatd q1, simd_quatd q2, simd_quatd q3, double t);
-
-/*! @abstract Spherical cubic Bezier interpolation between quaternions.
- *
- *  @discussion The function treats q0 ... q3 as control points and uses slerp
- *  in place of lerp in the De Castlejeau algorithm. The endpoints of
- *  interpolation are thus q0 and q3, and the curve will not generally pass
- *  through q1 or q2. Note that the convex hull property of "standard" Bezier
- *  curve does not hold on the sphere.                                        */
-static SIMD_NOINLINE simd_quatd simd_bezier(simd_quatd q0, simd_quatd q1, simd_quatd q2, simd_quatd q3, double t);
-  
-#ifdef __cplusplus
-} /* extern "C" */
-/*  MARK: - C++ double interfaces                                              */
-
-namespace simd {
-  struct quatd : ::simd_quatd {
-    /*! @abstract The identity quaternion.                                    */
-    quatd( ) : ::simd_quatd(::simd_quaternion((double4){0,0,0,1})) { }
-    
-    /*! @abstract Constructs a C++ quaternion from a C quaternion.            */
-    quatd(::simd_quatd q) : ::simd_quatd(q) { }
-    
-    /*! @abstract Constructs a quaternion from components.                    */
-    quatd(double ix, double iy, double iz, double r) : ::simd_quatd(::simd_quaternion(ix, iy, iz, r)) { }
-    
-    /*! @abstract Constructs a quaternion from an array of scalars.           */
-    quatd(const double xyzr[4]) : ::simd_quatd(::simd_quaternion(xyzr)) { }
-    
-    /*! @abstract Constructs a quaternion from a vector.                      */
-    quatd(double4 xyzr) : ::simd_quatd(::simd_quaternion(xyzr)) { }
-    
-    /*! @abstract Quaternion representing rotation about `axis` by `angle` 
-     *  radians.                                                              */
-    quatd(double angle, double3 axis) : ::simd_quatd(::simd_quaternion(angle, axis)) { }
-    
-    /*! @abstract Quaternion that rotates `from` into `to`.                   */
-    quatd(double3 from, double3 to) : ::simd_quatd(::simd_quaternion(from, to)) { }
-    
-    /*! @abstract Constructs a quaternion from a rotation matrix.             */
-    quatd(::simd_double3x3 matrix) : ::simd_quatd(::simd_quaternion(matrix)) { }
-    
-    /*! @abstract Constructs a quaternion from a rotation matrix.             */
-    quatd(::simd_double4x4 matrix) : ::simd_quatd(::simd_quaternion(matrix)) { }
-  
-    /*! @abstract The real (scalar) part of the quaternion.                   */
-    double real(void) const { return ::simd_real(*this); }
-    
-    /*! @abstract The imaginary (vector) part of the quaternion.              */
-    double3 imag(void) const { return ::simd_imag(*this); }
-    
-    /*! @abstract The angle the quaternion rotates by.                        */
-    double angle(void) const { return ::simd_angle(*this); }
-    
-    /*! @abstract The axis the quaternion rotates about.                      */
-    double3 axis(void) const { return ::simd_axis(*this); }
-    
-    /*! @abstract The length of the quaternion.                               */
-    double length(void) const { return ::simd_length(*this); }
-    
-    /*! @abstract Act on the vector `v` by rotation.                          */
-    double3  operator()(const ::simd_double3 v) const { return ::simd_act(*this, v); }
-  };
-  
-  static SIMD_CPPFUNC quatd operator+(const ::simd_quatd p, const ::simd_quatd q) { return ::simd_add(p, q); }
-  static SIMD_CPPFUNC quatd operator-(const ::simd_quatd p, const ::simd_quatd q) { return ::simd_sub(p, q); }
-  static SIMD_CPPFUNC quatd operator-(const ::simd_quatd p) { return ::simd_negate(p); }
-  static SIMD_CPPFUNC quatd operator*(const double r, const ::simd_quatd p) { return ::simd_mul(r, p); }
-  static SIMD_CPPFUNC quatd operator*(const ::simd_quatd p, const double r) { return ::simd_mul(p, r); }
-  static SIMD_CPPFUNC quatd operator*(const ::simd_quatd p, const ::simd_quatd q) { return ::simd_mul(p, q); }
-  static SIMD_CPPFUNC quatd operator/(const ::simd_quatd p, const ::simd_quatd q) { return ::simd_mul(p, ::simd_inverse(q)); }
-  static SIMD_CPPFUNC quatd operator+=(quatd &p, const ::simd_quatd q) { return p = p+q; }
-  static SIMD_CPPFUNC quatd operator-=(quatd &p, const ::simd_quatd q) { return p = p-q; }
-  static SIMD_CPPFUNC quatd operator*=(quatd &p, const double r) { return p = p*r; }
-  static SIMD_CPPFUNC quatd operator*=(quatd &p, const ::simd_quatd q) { return p = p*q; }
-  static SIMD_CPPFUNC quatd operator/=(quatd &p, const ::simd_quatd q) { return p = p/q; }
-  
-  /*! @abstract The conjugate of the quaternion `q`.                          */
-  static SIMD_CPPFUNC quatd conjugate(const ::simd_quatd p) { return ::simd_conjugate(p); }
-  
-  /*! @abstract The (multiplicative) inverse of the quaternion `q`.           */
-  static SIMD_CPPFUNC quatd inverse(const ::simd_quatd p) { return ::simd_inverse(p); }
-
-  /*! @abstract The dot product of the quaternions `p` and `q` interpreted as
-   *  four-dimensional vectors.                                               */
-  static SIMD_CPPFUNC double dot(const ::simd_quatd p, const ::simd_quatd q) { return ::simd_dot(p, q); }
-  
-  /*! @abstract The unit quaternion obtained by normalizing `q`.              */
-  static SIMD_CPPFUNC quatd normalize(const ::simd_quatd p) { return ::simd_normalize(p); }
-
-  /*! @abstract logarithm of the quaternion `q`.                              */
-  static SIMD_CPPFUNC quatd log(const ::simd_quatd q) { return ::__tg_log(q); }
-
-  /*! @abstract exponential map of quaterion `q`.                             */
-  static SIMD_CPPFUNC quatd exp(const ::simd_quatd q) { return ::__tg_exp(q); }
-  
-  /*! @abstract Spherical linear interpolation along the shortest arc between
-   *  quaternions `q0` and `q1`.                                              */
-  static SIMD_CPPFUNC quatd slerp(const ::simd_quatd p0, const ::simd_quatd p1, double t) { return ::simd_slerp(p0, p1, t); }
-  
-  /*! @abstract Spherical linear interpolation along the longest arc between
-   *  quaternions `q0` and `q1`.                                              */
-  static SIMD_CPPFUNC quatd slerp_longest(const ::simd_quatd p0, const ::simd_quatd p1, double t) { return ::simd_slerp_longest(p0, p1, t); }
-  
-  /*! @abstract Interpolate between quaternions along a spherical cubic spline.
-   *
-   *  @discussion The function interpolates between q1 and q2. q0 is the left
-   *  endpoint of the previous interval, and q3 is the right endpoint of the next
-   *  interval. Use this function to smoothly interpolate between a sequence of
-   *  rotations.                                                              */
-  static SIMD_CPPFUNC quatd spline(const ::simd_quatd p0, const ::simd_quatd p1, const ::simd_quatd p2, const ::simd_quatd p3, double t) { return ::simd_spline(p0, p1, p2, p3, t); }
-  
-  /*! @abstract Spherical cubic Bezier interpolation between quaternions.
-   *
-   *  @discussion The function treats q0 ... q3 as control points and uses slerp
-   *  in place of lerp in the De Castlejeau algorithm. The endpoints of
-   *  interpolation are thus q0 and q3, and the curve will not generally pass
-   *  through q1 or q2. Note that the convex hull property of "standard" Bezier
-   *  curve does not hold on the sphere.                                      */
-  static SIMD_CPPFUNC quatd bezier(const ::simd_quatd p0, const ::simd_quatd p1, const ::simd_quatd p2, const ::simd_quatd p3, double t) { return ::simd_bezier(p0, p1, p2, p3, t); }
-}
-
-extern "C" {
-#endif /* __cplusplus */
-  
-/*  MARK: - double implementations                                             */
-
-#include <simd/math.h>
-#include <simd/geometry.h>
-  
-/*  tg_promote is implementation gobbledygook that enables the compile-time
- *  dispatching in tgmath.h to work its magic.                                */
-static simd_quatd __attribute__((__overloadable__)) __tg_promote(simd_quatd);
-  
-/*! @abstract Constructs a quaternion from imaginary and real parts.
- *  @discussion This function is hidden behind an underscore to avoid confusion
- *  with the angle-axis constructor.                                          */
-static inline SIMD_CFUNC simd_quatd _simd_quaternion(simd_double3 imag, double real) {
-  return simd_quaternion(simd_make_double4(imag, real));
-}
-  
-static inline SIMD_CFUNC simd_quatd simd_quaternion(double angle, simd_double3 axis) {
-  return _simd_quaternion(sin(angle/2) * axis, cos(angle/2));
-}
-  
-static inline SIMD_CFUNC double simd_angle(simd_quatd q) {
-  return 2*atan2(simd_length(q.vector.xyz), q.vector.w);
-}
-  
-static inline SIMD_CFUNC simd_double3 simd_axis(simd_quatd q) {
-  return simd_normalize(q.vector.xyz);
-}
-  
-static inline SIMD_CFUNC simd_quatd simd_add(simd_quatd p, simd_quatd q) {
-  return simd_quaternion(p.vector + q.vector);
-}
-  
-static inline SIMD_CFUNC simd_quatd simd_sub(simd_quatd p, simd_quatd q) {
-  return simd_quaternion(p.vector - q.vector);
-}
-
-static inline SIMD_CFUNC simd_quatd simd_mul(simd_quatd p, simd_quatd q) {
-  #pragma STDC FP_CONTRACT ON
-  return simd_quaternion((p.vector.x * __builtin_shufflevector(q.vector, -q.vector, 3,6,1,4) +
-                          p.vector.y * __builtin_shufflevector(q.vector, -q.vector, 2,3,4,5)) +
-                         (p.vector.z * __builtin_shufflevector(q.vector, -q.vector, 5,0,3,6) +
-                          p.vector.w * q.vector));
-}
-
-static inline SIMD_CFUNC simd_quatd simd_mul(simd_quatd q, double a) {
-  return simd_quaternion(a * q.vector);
-}
-
-static inline SIMD_CFUNC simd_quatd simd_mul(double a, simd_quatd q) {
-  return simd_mul(q,a);
-}
-  
-static inline SIMD_CFUNC simd_quatd simd_conjugate(simd_quatd q) {
-  return simd_quaternion(q.vector * (simd_double4){-1,-1,-1, 1});
-}
-  
-static inline SIMD_CFUNC simd_quatd simd_inverse(simd_quatd q) {
-  return simd_quaternion(simd_conjugate(q).vector * simd_recip(simd_length_squared(q.vector)));
-}
-  
-static inline SIMD_CFUNC simd_quatd simd_negate(simd_quatd q) {
-  return simd_quaternion(-q.vector);
-}
-  
-static inline SIMD_CFUNC double simd_dot(simd_quatd p, simd_quatd q) {
-  return simd_dot(p.vector, q.vector);
-}
-  
-static inline SIMD_CFUNC double simd_length(simd_quatd q) {
-  return simd_length(q.vector);
-}
-  
-static inline SIMD_CFUNC simd_quatd simd_normalize(simd_quatd q) {
-  double length_squared = simd_length_squared(q.vector);
-  if (length_squared == 0) {
-    return simd_quaternion((simd_double4){0,0,0,1});
-  }
-  return simd_quaternion(q.vector * simd_rsqrt(length_squared));
-}
-
-#if defined __arm__ || defined __arm64__
-/*! @abstract Multiplies the vector `v` by the quaternion `q`.
- *  
- *  @discussion This IS NOT the action of `q` on `v` (i.e. this is not rotation
- *  by `q`. That operation is provided by `simd_act(q, v)`. This function is an
- *  implementation detail and you should not call it directly. It may be
- *  removed or modified in future versions of the simd module.                */
-static inline SIMD_CFUNC simd_quatd _simd_mul_vq(simd_double3 v, simd_quatd q) {
-  #pragma STDC FP_CONTRACT ON
-  return simd_quaternion(v.x * __builtin_shufflevector(q.vector, -q.vector, 3,6,1,4) +
-                         v.y * __builtin_shufflevector(q.vector, -q.vector, 2,3,4,5) +
-                         v.z * __builtin_shufflevector(q.vector, -q.vector, 5,0,3,6));
-}
-#endif
-  
-static inline SIMD_CFUNC simd_double3 simd_act(simd_quatd q, simd_double3 v) {
-#if defined __arm__ || defined __arm64__
-  return simd_mul(q, _simd_mul_vq(v, simd_conjugate(q))).vector.xyz;
-#else
-  #pragma STDC FP_CONTRACT ON
-  simd_double3 t = 2*simd_cross(simd_imag(q),v);
-  return v + simd_real(q)*t + simd_cross(simd_imag(q), t);
-#endif
-}
-
-static SIMD_NOINLINE simd_quatd __tg_log(simd_quatd q) {
-  double real = __tg_log(simd_length_squared(q.vector))/2;
-  if (simd_equal(simd_imag(q), 0)) return _simd_quaternion(0, real);
-  simd_double3 imag = __tg_acos(simd_real(q)/simd_length(q)) * simd_normalize(simd_imag(q));
-  return _simd_quaternion(imag, real);
-}
-  
-static SIMD_NOINLINE simd_quatd __tg_exp(simd_quatd q) {
-  //  angle is actually *twice* the angle of the rotation corresponding to
-  //  the resulting quaternion, which is why we don't simply use the (angle,
-  //  axis) constructor to generate `unit`.
-  double angle = simd_length(simd_imag(q));
-  if (angle == 0) return _simd_quaternion(0, exp(simd_real(q)));
-  simd_double3 axis = simd_normalize(simd_imag(q));
-  simd_quatd unit = _simd_quaternion(sin(angle)*axis, cosf(angle));
-  return simd_mul(exp(simd_real(q)), unit);
-}
- 
-/*! @abstract Implementation detail of the `simd_quaternion(from, to)`
- *  initializer.
- *
- *  @discussion Computes the quaternion rotation `from` to `to` if they are
- *  separated by less than 90 degrees. Not numerically stable for larger
- *  angles. This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static inline SIMD_CFUNC simd_quatd _simd_quaternion_reduced(simd_double3 from, simd_double3 to) {
-  simd_double3 half = simd_normalize(from + to);
-  return _simd_quaternion(simd_cross(from, half), simd_dot(from, half));
-}
-
-static SIMD_NOINLINE simd_quatd simd_quaternion(simd_double3 from, simd_double3 to) {
-  
-  //  If the angle between from and to is not too big, we can compute the
-  //  rotation accurately using a simple implementation.
-  if (simd_dot(from, to) >= 0) {
-    return _simd_quaternion_reduced(from, to);
-  }
-  
-  //  Because from and to are more than 90 degrees apart, we compute the
-  //  rotation in two stages (from -> half), (half -> to) to preserve numerical
-  //  accuracy.
-  simd_double3 half = simd_normalize(from + to);
-  
-  if (simd_length_squared(half) == 0) {
-    //  half is nearly zero, so from and to point in nearly opposite directions
-    //  and the rotation is numerically underspecified. Pick an axis orthogonal
-    //  to the vectors, and use an angle of pi radians.
-    simd_double3 abs_from = simd_abs(from);
-    if (abs_from.x <= abs_from.y && abs_from.x <= abs_from.z)
-      return _simd_quaternion(simd_normalize(simd_cross(from, (simd_double3){1,0,0})), 0.f);
-    else if (abs_from.y <= abs_from.z)
-      return _simd_quaternion(simd_normalize(simd_cross(from, (simd_double3){0,1,0})), 0.f);
-    else
-      return _simd_quaternion(simd_normalize(simd_cross(from, (simd_double3){0,0,1})), 0.f);
-  }
-  
-  //  Compute the two-step rotation.                         */
-  return simd_mul(_simd_quaternion_reduced(from, half),
-                  _simd_quaternion_reduced(half, to));
-}
-
-static SIMD_NOINLINE simd_quatd simd_quaternion(simd_double3x3 matrix) {
-  const simd_double3 *mat = matrix.columns;
-  double trace = mat[0][0] + mat[1][1] + mat[2][2];
-  if (trace >= 0.0) {
-    double r = 2*sqrt(1 + trace);
-    double rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[1][2] - mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]),
-                           rinv*(mat[0][1] - mat[1][0]),
-                           r/4);
-  } else if (mat[0][0] >= mat[1][1] && mat[0][0] >= mat[2][2]) {
-    double r = 2*sqrt(1 - mat[1][1] - mat[2][2] + mat[0][0]);
-    double rinv = simd_recip(r);
-    return simd_quaternion(r/4,
-                           rinv*(mat[0][1] + mat[1][0]),
-                           rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] - mat[2][1]));
-  } else if (mat[1][1] >= mat[2][2]) {
-    double r = 2*sqrt(1 - mat[0][0] - mat[2][2] + mat[1][1]);
-    double rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][1] + mat[1][0]),
-                           r/4,
-                           rinv*(mat[1][2] + mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]));
-  } else {
-    double r = 2*sqrt(1 - mat[0][0] - mat[1][1] + mat[2][2]);
-    double rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] + mat[2][1]),
-                           r/4,
-                           rinv*(mat[0][1] - mat[1][0]));
-  }
-}
-  
-static SIMD_NOINLINE simd_quatd simd_quaternion(simd_double4x4 matrix) {
-  const simd_double4 *mat = matrix.columns;
-  double trace = mat[0][0] + mat[1][1] + mat[2][2];
-  if (trace >= 0.0) {
-    double r = 2*sqrt(1 + trace);
-    double rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[1][2] - mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]),
-                           rinv*(mat[0][1] - mat[1][0]),
-                           r/4);
-  } else if (mat[0][0] >= mat[1][1] && mat[0][0] >= mat[2][2]) {
-    double r = 2*sqrt(1 - mat[1][1] - mat[2][2] + mat[0][0]);
-    double rinv = simd_recip(r);
-    return simd_quaternion(r/4,
-                           rinv*(mat[0][1] + mat[1][0]),
-                           rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] - mat[2][1]));
-  } else if (mat[1][1] >= mat[2][2]) {
-    double r = 2*sqrt(1 - mat[0][0] - mat[2][2] + mat[1][1]);
-    double rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][1] + mat[1][0]),
-                           r/4,
-                           rinv*(mat[1][2] + mat[2][1]),
-                           rinv*(mat[2][0] - mat[0][2]));
-  } else {
-    double r = 2*sqrt(1 - mat[0][0] - mat[1][1] + mat[2][2]);
-    double rinv = simd_recip(r);
-    return simd_quaternion(rinv*(mat[0][2] + mat[2][0]),
-                           rinv*(mat[1][2] + mat[2][1]),
-                           r/4,
-                           rinv*(mat[0][1] - mat[1][0]));
-  }
-}
-  
-/*! @abstract The angle between p and q interpreted as 4-dimensional vectors.
- *
- *  @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_NOINLINE double _simd_angle(simd_quatd p, simd_quatd q) {
-  return 2*atan2(simd_length(p.vector - q.vector), simd_length(p.vector + q.vector));
-}
-  
-/*! @abstract sin(x)/x.
- *
- *  @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_CFUNC double _simd_sinc(double x) {
-  if (x == 0) return 1;
-  return sin(x)/x;
-}
- 
-/*! @abstract Spherical lerp between q0 and q1.
- *
- *  @discussion This function may interpolate along either the longer or
- *  shorter path between q0 and q1; it is used as an implementation detail
- *  in `simd_slerp` and `simd_slerp_longest`; you should use those functions
- *  instead of calling this directly.                                         */
-static SIMD_NOINLINE simd_quatd _simd_slerp_internal(simd_quatd q0, simd_quatd q1, double t) {
-  double s = 1 - t;
-  double a = _simd_angle(q0, q1);
-  double r = simd_recip(_simd_sinc(a));
-  return simd_normalize(simd_quaternion(_simd_sinc(s*a)*r*s*q0.vector + _simd_sinc(t*a)*r*t*q1.vector));
-}
-  
-static SIMD_NOINLINE simd_quatd simd_slerp(simd_quatd q0, simd_quatd q1, double t) {
-  if (simd_dot(q0, q1) >= 0)
-    return _simd_slerp_internal(q0, q1, t);
-  return _simd_slerp_internal(q0, simd_negate(q1), t);
-}
-
-static SIMD_NOINLINE simd_quatd simd_slerp_longest(simd_quatd q0, simd_quatd q1, double t) {
-  if (simd_dot(q0, q1) >= 0)
-    return _simd_slerp_internal(q0, simd_negate(q1), t);
-  return _simd_slerp_internal(q0, q1, t);
-}
-  
-/*! @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_NOINLINE simd_quatd _simd_intermediate(simd_quatd q0, simd_quatd q1, simd_quatd q2) {
-  simd_quatd p0 = __tg_log(simd_mul(q0, simd_inverse(q1)));
-  simd_quatd p2 = __tg_log(simd_mul(q2, simd_inverse(q1)));
-  return simd_normalize(simd_mul(q1, __tg_exp(simd_mul(-0.25, simd_add(p0,p2)))));
-}
-
-/*! @discussion This function is an implementation detail and you should not
- *  call it directly. It may be removed or modified in future versions of the
- *  simd module.                                                              */
-static SIMD_NOINLINE simd_quatd _simd_squad(simd_quatd q0, simd_quatd qa, simd_quatd qb, simd_quatd q1, double t) {
-  simd_quatd r0 = _simd_slerp_internal(q0, q1, t);
-  simd_quatd r1 = _simd_slerp_internal(qa, qb, t);
-  return _simd_slerp_internal(r0, r1, 2*t*(1 - t));
-}
-  
-static SIMD_NOINLINE simd_quatd simd_spline(simd_quatd q0, simd_quatd q1, simd_quatd q2, simd_quatd q3, double t) {
-  simd_quatd qa = _simd_intermediate(q0, q1, q2);
-  simd_quatd qb = _simd_intermediate(q1, q2, q3);
-  return _simd_squad(q1, qa, qb, q2, t);
-}
-  
-static SIMD_NOINLINE simd_quatd simd_bezier(simd_quatd q0, simd_quatd q1, simd_quatd q2, simd_quatd q3, double t) {
-  simd_quatd q01 = _simd_slerp_internal(q0, q1, t);
-  simd_quatd q12 = _simd_slerp_internal(q1, q2, t);
-  simd_quatd q23 = _simd_slerp_internal(q2, q3, t);
-  simd_quatd q012 = _simd_slerp_internal(q01, q12, t);
-  simd_quatd q123 = _simd_slerp_internal(q12, q23, t);
-  return _simd_slerp_internal(q012, q123, t);
-}
-
-#ifdef __cplusplus
-}      /* extern "C"  */
-#endif /* __cplusplus */
-#endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */
-#endif /* SIMD_QUATERNIONS */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/simd/vector_make.h b/lib/libc/include/x86_64-macos.10-none/simd/vector_make.h
deleted file mode 100644
index b8e2323944..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/simd/vector_make.h
+++ /dev/null
@@ -1,6768 +0,0 @@
-/*! @header
- *  This header defines functions for constructing, extending, and truncating
- *  simd vector types.
- *
- *  For each vector type `simd_typeN` supported by <simd/simd.h>, the following
- *  constructors are provided:
- *
- *  ~~~
- *  simd_typeN simd_make_typeN(type other);
- *  simd_typeN simd_make_typeN(simd_typeM other);
- *  ~~~
- *  For the scalar-input version, or if M < N, these functions zero-extend
- *  `other` to produce a wider vector. If M == N, `other` is passed through
- *  unmodified. If `M > N`, `other` is truncated to form the result.
- *
- *  ~~~
- *  simd_typeN simd_make_typeN_undef(type other);
- *  simd_typeN simd_make_typeN_undef(simd_typeM other);
- *  ~~~
- *  These functions are only available for M < N and for scalar inputs. They 
- *  extend `other` to produce a wider vector where the contents of the newly-
- *  formed lanes are undefined.
- *
- *  In addition, if N is 2, 3, or 4, the following constructors are available:
- *  ~~~
- *  simd_make_typeN(parts ...)
- *  ~~~
- *  where parts is a list of scalars and smaller vectors such that the sum of
- *  the number of lanes in the arguments is equal to N. For example, a
- *  `simd_float3` can be constructed from three `floats`, or a `float` and a
- *  `simd_float2` in any order:
- *  ~~~
- *  simd_float2 ab = { 1, 2 };
- *  simd_float3 vector = simd_make_float3(ab, 3);
- *  ~~~
- *
- *  @copyright 2014-2016 Apple, Inc. All rights reserved.
- *  @unsorted                                                                 */
-
-#ifndef SIMD_VECTOR_CONSTRUCTORS
-#define SIMD_VECTOR_CONSTRUCTORS
-
-#include <simd/vector_types.h>
-#if SIMD_COMPILER_HAS_REQUIRED_FEATURES
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char2 simd_make_char2(char x, char y) {
-  simd_char2 result;
-  result.x = x;
-  result.y = y;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of two 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char2 simd_make_char2(char other) {
-  simd_char2 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of two 8-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_char2 simd_make_char2_undef(char other) {
-  simd_char2 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_char2 simd_make_char2(simd_char2 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 8-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_char2 simd_make_char2(simd_char3 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 8-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_char2 simd_make_char2(simd_char4 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 8-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_char2 simd_make_char2(simd_char8 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 8-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_char2 simd_make_char2(simd_char16 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 8-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_char2 simd_make_char2(simd_char32 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 8-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_char2 simd_make_char2(simd_char64 other) {
-  return other.xy;
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char3 simd_make_char3(char x, char y, char z) {
-  simd_char3 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char3 simd_make_char3(char x, simd_char2 yz) {
-  simd_char3 result;
-  result.x = x;
-  result.yz = yz;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char3 simd_make_char3(simd_char2 xy, char z) {
-  simd_char3 result;
-  result.xy = xy;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of three 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char3 simd_make_char3(char other) {
-  simd_char3 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 8-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_char3 simd_make_char3_undef(char other) {
-  simd_char3 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of three 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char3 simd_make_char3(simd_char2 other) {
-  simd_char3 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 8-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_char3 simd_make_char3_undef(simd_char2 other) {
-  simd_char3 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_char3 simd_make_char3(simd_char3 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char3 simd_make_char3(simd_char4 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char3 simd_make_char3(simd_char8 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char3 simd_make_char3(simd_char16 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char3 simd_make_char3(simd_char32 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char3 simd_make_char3(simd_char64 other) {
-  return other.xyz;
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  8-bit signed (twos-complement) integers.                                  */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(char x, char y, char z, char w) {
-  simd_char4 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(char x, char y, simd_char2 zw) {
-  simd_char4 result;
-  result.x = x;
-  result.y = y;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(char x, simd_char2 yz, char w) {
-  simd_char4 result;
-  result.x = x;
-  result.yz = yz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(simd_char2 xy, char z, char w) {
-  simd_char4 result;
-  result.xy = xy;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(char x, simd_char3 yzw) {
-  simd_char4 result;
-  result.x = x;
-  result.yzw = yzw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(simd_char2 xy, simd_char2 zw) {
-  simd_char4 result;
-  result.xy = xy;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(simd_char3 xyz, char w) {
-  simd_char4 result;
-  result.xyz = xyz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of four 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(char other) {
-  simd_char4 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 8-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_char4 simd_make_char4_undef(char other) {
-  simd_char4 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(simd_char2 other) {
-  simd_char4 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 8-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_char4 simd_make_char4_undef(simd_char2 other) {
-  simd_char4 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(simd_char3 other) {
-  simd_char4 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 8-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_char4 simd_make_char4_undef(simd_char3 other) {
-  simd_char4 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(simd_char4 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 8-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(simd_char8 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 8-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(simd_char16 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 8-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(simd_char32 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 8-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_char4 simd_make_char4(simd_char64 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char8 simd_make_char8(simd_char4 lo, simd_char4 hi) {
-  simd_char8 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char8 simd_make_char8(char other) {
-  simd_char8 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 8-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_char8 simd_make_char8_undef(char other) {
-  simd_char8 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char8 simd_make_char8(simd_char2 other) {
-  simd_char8 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 8-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_char8 simd_make_char8_undef(simd_char2 other) {
-  simd_char8 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char8 simd_make_char8(simd_char3 other) {
-  simd_char8 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 8-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_char8 simd_make_char8_undef(simd_char3 other) {
-  simd_char8 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char8 simd_make_char8(simd_char4 other) {
-  simd_char8 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 8-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_char8 simd_make_char8_undef(simd_char4 other) {
-  simd_char8 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_char8 simd_make_char8(simd_char8 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of eight 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char8 simd_make_char8(simd_char16 other) {
-  return simd_make_char8(other.lo);
-}
-
-/*! @abstract Truncates `other` to form a vector of eight 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char8 simd_make_char8(simd_char32 other) {
-  return simd_make_char8(other.lo);
-}
-
-/*! @abstract Truncates `other` to form a vector of eight 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char8 simd_make_char8(simd_char64 other) {
-  return simd_make_char8(other.lo);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixteen 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char16 simd_make_char16(simd_char8 lo, simd_char8 hi) {
-  simd_char16 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char16 simd_make_char16(char other) {
-  simd_char16 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char16 simd_make_char16_undef(char other) {
-  simd_char16 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char16 simd_make_char16(simd_char2 other) {
-  simd_char16 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char16 simd_make_char16_undef(simd_char2 other) {
-  simd_char16 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char16 simd_make_char16(simd_char3 other) {
-  simd_char16 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char16 simd_make_char16_undef(simd_char3 other) {
-  simd_char16 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char16 simd_make_char16(simd_char4 other) {
-  simd_char16 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char16 simd_make_char16_undef(simd_char4 other) {
-  simd_char16 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char16 simd_make_char16(simd_char8 other) {
-  simd_char16 result = 0;
-  result.lo = simd_make_char8(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char16 simd_make_char16_undef(simd_char8 other) {
-  simd_char16 result;
-  result.lo = simd_make_char8(other);
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_char16 simd_make_char16(simd_char16 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of sixteen 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char16 simd_make_char16(simd_char32 other) {
-  return simd_make_char16(other.lo);
-}
-
-/*! @abstract Truncates `other` to form a vector of sixteen 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char16 simd_make_char16(simd_char64 other) {
-  return simd_make_char16(other.lo);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of thirty-two
- *  8-bit signed (twos-complement) integers.                                  */
-static inline SIMD_CFUNC simd_char32 simd_make_char32(simd_char16 lo, simd_char16 hi) {
-  simd_char32 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char32 simd_make_char32(char other) {
-  simd_char32 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char32 simd_make_char32_undef(char other) {
-  simd_char32 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char32 simd_make_char32(simd_char2 other) {
-  simd_char32 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char32 simd_make_char32_undef(simd_char2 other) {
-  simd_char32 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char32 simd_make_char32(simd_char3 other) {
-  simd_char32 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char32 simd_make_char32_undef(simd_char3 other) {
-  simd_char32 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char32 simd_make_char32(simd_char4 other) {
-  simd_char32 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char32 simd_make_char32_undef(simd_char4 other) {
-  simd_char32 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char32 simd_make_char32(simd_char8 other) {
-  simd_char32 result = 0;
-  result.lo = simd_make_char16(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char32 simd_make_char32_undef(simd_char8 other) {
-  simd_char32 result;
-  result.lo = simd_make_char16(other);
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char32 simd_make_char32(simd_char16 other) {
-  simd_char32 result = 0;
-  result.lo = simd_make_char16(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char32 simd_make_char32_undef(simd_char16 other) {
-  simd_char32 result;
-  result.lo = simd_make_char16(other);
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_char32 simd_make_char32(simd_char32 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of thirty-two 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_char32 simd_make_char32(simd_char64 other) {
-  return simd_make_char32(other.lo);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixty-four
- *  8-bit signed (twos-complement) integers.                                  */
-static inline SIMD_CFUNC simd_char64 simd_make_char64(simd_char32 lo, simd_char32 hi) {
-  simd_char64 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixty-four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char64 simd_make_char64(char other) {
-  simd_char64 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char64 simd_make_char64_undef(char other) {
-  simd_char64 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixty-four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char64 simd_make_char64(simd_char2 other) {
-  simd_char64 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char64 simd_make_char64_undef(simd_char2 other) {
-  simd_char64 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixty-four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char64 simd_make_char64(simd_char3 other) {
-  simd_char64 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char64 simd_make_char64_undef(simd_char3 other) {
-  simd_char64 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixty-four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char64 simd_make_char64(simd_char4 other) {
-  simd_char64 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char64 simd_make_char64_undef(simd_char4 other) {
-  simd_char64 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixty-four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char64 simd_make_char64(simd_char8 other) {
-  simd_char64 result = 0;
-  result.lo = simd_make_char32(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char64 simd_make_char64_undef(simd_char8 other) {
-  simd_char64 result;
-  result.lo = simd_make_char32(other);
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixty-four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char64 simd_make_char64(simd_char16 other) {
-  simd_char64 result = 0;
-  result.lo = simd_make_char32(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char64 simd_make_char64_undef(simd_char16 other) {
-  simd_char64 result;
-  result.lo = simd_make_char32(other);
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixty-four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_char64 simd_make_char64(simd_char32 other) {
-  simd_char64 result = 0;
-  result.lo = simd_make_char32(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_char64 simd_make_char64_undef(simd_char32 other) {
-  simd_char64 result;
-  result.lo = simd_make_char32(other);
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_char64 simd_make_char64(simd_char64 other) {
-  return other;
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar2 simd_make_uchar2(unsigned char x, unsigned char y) {
-  simd_uchar2 result;
-  result.x = x;
-  result.y = y;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of two 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar2 simd_make_uchar2(unsigned char other) {
-  simd_uchar2 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of two 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar2 simd_make_uchar2_undef(unsigned char other) {
-  simd_uchar2 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_uchar2 simd_make_uchar2(simd_uchar2 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar2 simd_make_uchar2(simd_uchar3 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar2 simd_make_uchar2(simd_uchar4 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar2 simd_make_uchar2(simd_uchar8 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar2 simd_make_uchar2(simd_uchar16 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar2 simd_make_uchar2(simd_uchar32 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar2 simd_make_uchar2(simd_uchar64 other) {
-  return other.xy;
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar3 simd_make_uchar3(unsigned char x, unsigned char y, unsigned char z) {
-  simd_uchar3 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar3 simd_make_uchar3(unsigned char x, simd_uchar2 yz) {
-  simd_uchar3 result;
-  result.x = x;
-  result.yz = yz;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar3 simd_make_uchar3(simd_uchar2 xy, unsigned char z) {
-  simd_uchar3 result;
-  result.xy = xy;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of three 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar3 simd_make_uchar3(unsigned char other) {
-  simd_uchar3 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar3 simd_make_uchar3_undef(unsigned char other) {
-  simd_uchar3 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of three 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar3 simd_make_uchar3(simd_uchar2 other) {
-  simd_uchar3 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar3 simd_make_uchar3_undef(simd_uchar2 other) {
-  simd_uchar3 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_uchar3 simd_make_uchar3(simd_uchar3 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar3 simd_make_uchar3(simd_uchar4 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar3 simd_make_uchar3(simd_uchar8 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar3 simd_make_uchar3(simd_uchar16 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar3 simd_make_uchar3(simd_uchar32 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar3 simd_make_uchar3(simd_uchar64 other) {
-  return other.xyz;
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  8-bit unsigned integers.                                                  */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w) {
-  simd_uchar4 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(unsigned char x, unsigned char y, simd_uchar2 zw) {
-  simd_uchar4 result;
-  result.x = x;
-  result.y = y;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(unsigned char x, simd_uchar2 yz, unsigned char w) {
-  simd_uchar4 result;
-  result.x = x;
-  result.yz = yz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(simd_uchar2 xy, unsigned char z, unsigned char w) {
-  simd_uchar4 result;
-  result.xy = xy;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(unsigned char x, simd_uchar3 yzw) {
-  simd_uchar4 result;
-  result.x = x;
-  result.yzw = yzw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(simd_uchar2 xy, simd_uchar2 zw) {
-  simd_uchar4 result;
-  result.xy = xy;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(simd_uchar3 xyz, unsigned char w) {
-  simd_uchar4 result;
-  result.xyz = xyz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of four 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(unsigned char other) {
-  simd_uchar4 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4_undef(unsigned char other) {
-  simd_uchar4 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(simd_uchar2 other) {
-  simd_uchar4 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4_undef(simd_uchar2 other) {
-  simd_uchar4 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(simd_uchar3 other) {
-  simd_uchar4 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4_undef(simd_uchar3 other) {
-  simd_uchar4 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(simd_uchar4 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(simd_uchar8 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(simd_uchar16 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(simd_uchar32 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar4 simd_make_uchar4(simd_uchar64 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar8 simd_make_uchar8(simd_uchar4 lo, simd_uchar4 hi) {
-  simd_uchar8 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar8 simd_make_uchar8(unsigned char other) {
-  simd_uchar8 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar8 simd_make_uchar8_undef(unsigned char other) {
-  simd_uchar8 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar8 simd_make_uchar8(simd_uchar2 other) {
-  simd_uchar8 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar8 simd_make_uchar8_undef(simd_uchar2 other) {
-  simd_uchar8 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar8 simd_make_uchar8(simd_uchar3 other) {
-  simd_uchar8 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar8 simd_make_uchar8_undef(simd_uchar3 other) {
-  simd_uchar8 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar8 simd_make_uchar8(simd_uchar4 other) {
-  simd_uchar8 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar8 simd_make_uchar8_undef(simd_uchar4 other) {
-  simd_uchar8 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_uchar8 simd_make_uchar8(simd_uchar8 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of eight 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar8 simd_make_uchar8(simd_uchar16 other) {
-  return simd_make_uchar8(other.lo);
-}
-
-/*! @abstract Truncates `other` to form a vector of eight 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar8 simd_make_uchar8(simd_uchar32 other) {
-  return simd_make_uchar8(other.lo);
-}
-
-/*! @abstract Truncates `other` to form a vector of eight 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar8 simd_make_uchar8(simd_uchar64 other) {
-  return simd_make_uchar8(other.lo);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixteen 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar16 simd_make_uchar16(simd_uchar8 lo, simd_uchar8 hi) {
-  simd_uchar16 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar16 simd_make_uchar16(unsigned char other) {
-  simd_uchar16 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar16 simd_make_uchar16_undef(unsigned char other) {
-  simd_uchar16 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar16 simd_make_uchar16(simd_uchar2 other) {
-  simd_uchar16 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar16 simd_make_uchar16_undef(simd_uchar2 other) {
-  simd_uchar16 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar16 simd_make_uchar16(simd_uchar3 other) {
-  simd_uchar16 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar16 simd_make_uchar16_undef(simd_uchar3 other) {
-  simd_uchar16 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar16 simd_make_uchar16(simd_uchar4 other) {
-  simd_uchar16 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar16 simd_make_uchar16_undef(simd_uchar4 other) {
-  simd_uchar16 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar16 simd_make_uchar16(simd_uchar8 other) {
-  simd_uchar16 result = 0;
-  result.lo = simd_make_uchar8(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar16 simd_make_uchar16_undef(simd_uchar8 other) {
-  simd_uchar16 result;
-  result.lo = simd_make_uchar8(other);
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_uchar16 simd_make_uchar16(simd_uchar16 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of sixteen 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar16 simd_make_uchar16(simd_uchar32 other) {
-  return simd_make_uchar16(other.lo);
-}
-
-/*! @abstract Truncates `other` to form a vector of sixteen 8-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uchar16 simd_make_uchar16(simd_uchar64 other) {
-  return simd_make_uchar16(other.lo);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of thirty-two
- *  8-bit unsigned integers.                                                  */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32(simd_uchar16 lo, simd_uchar16 hi) {
-  simd_uchar32 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32(unsigned char other) {
-  simd_uchar32 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32_undef(unsigned char other) {
-  simd_uchar32 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32(simd_uchar2 other) {
-  simd_uchar32 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32_undef(simd_uchar2 other) {
-  simd_uchar32 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32(simd_uchar3 other) {
-  simd_uchar32 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32_undef(simd_uchar3 other) {
-  simd_uchar32 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32(simd_uchar4 other) {
-  simd_uchar32 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32_undef(simd_uchar4 other) {
-  simd_uchar32 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32(simd_uchar8 other) {
-  simd_uchar32 result = 0;
-  result.lo = simd_make_uchar16(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32_undef(simd_uchar8 other) {
-  simd_uchar32 result;
-  result.lo = simd_make_uchar16(other);
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32(simd_uchar16 other) {
-  simd_uchar32 result = 0;
-  result.lo = simd_make_uchar16(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32_undef(simd_uchar16 other) {
-  simd_uchar32 result;
-  result.lo = simd_make_uchar16(other);
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32(simd_uchar32 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of thirty-two 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar32 simd_make_uchar32(simd_uchar64 other) {
-  return simd_make_uchar32(other.lo);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixty-four
- *  8-bit unsigned integers.                                                  */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64(simd_uchar32 lo, simd_uchar32 hi) {
-  simd_uchar64 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixty-four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64(unsigned char other) {
-  simd_uchar64 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64_undef(unsigned char other) {
-  simd_uchar64 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixty-four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64(simd_uchar2 other) {
-  simd_uchar64 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64_undef(simd_uchar2 other) {
-  simd_uchar64 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixty-four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64(simd_uchar3 other) {
-  simd_uchar64 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64_undef(simd_uchar3 other) {
-  simd_uchar64 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixty-four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64(simd_uchar4 other) {
-  simd_uchar64 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64_undef(simd_uchar4 other) {
-  simd_uchar64 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixty-four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64(simd_uchar8 other) {
-  simd_uchar64 result = 0;
-  result.lo = simd_make_uchar32(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64_undef(simd_uchar8 other) {
-  simd_uchar64 result;
-  result.lo = simd_make_uchar32(other);
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixty-four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64(simd_uchar16 other) {
-  simd_uchar64 result = 0;
-  result.lo = simd_make_uchar32(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64_undef(simd_uchar16 other) {
-  simd_uchar64 result;
-  result.lo = simd_make_uchar32(other);
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixty-four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64(simd_uchar32 other) {
-  simd_uchar64 result = 0;
-  result.lo = simd_make_uchar32(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64_undef(simd_uchar32 other) {
-  simd_uchar64 result;
-  result.lo = simd_make_uchar32(other);
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_uchar64 simd_make_uchar64(simd_uchar64 other) {
-  return other;
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short2 simd_make_short2(short x, short y) {
-  simd_short2 result;
-  result.x = x;
-  result.y = y;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of two 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short2 simd_make_short2(short other) {
-  simd_short2 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of two 16-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_short2 simd_make_short2_undef(short other) {
-  simd_short2 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_short2 simd_make_short2(simd_short2 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 16-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_short2 simd_make_short2(simd_short3 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 16-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_short2 simd_make_short2(simd_short4 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 16-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_short2 simd_make_short2(simd_short8 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 16-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_short2 simd_make_short2(simd_short16 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 16-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_short2 simd_make_short2(simd_short32 other) {
-  return other.xy;
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short3 simd_make_short3(short x, short y, short z) {
-  simd_short3 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short3 simd_make_short3(short x, simd_short2 yz) {
-  simd_short3 result;
-  result.x = x;
-  result.yz = yz;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short3 simd_make_short3(simd_short2 xy, short z) {
-  simd_short3 result;
-  result.xy = xy;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of three 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short3 simd_make_short3(short other) {
-  simd_short3 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 16-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_short3 simd_make_short3_undef(short other) {
-  simd_short3 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of three 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short3 simd_make_short3(simd_short2 other) {
-  simd_short3 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 16-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_short3 simd_make_short3_undef(simd_short2 other) {
-  simd_short3 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_short3 simd_make_short3(simd_short3 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short3 simd_make_short3(simd_short4 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short3 simd_make_short3(simd_short8 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short3 simd_make_short3(simd_short16 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short3 simd_make_short3(simd_short32 other) {
-  return other.xyz;
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  16-bit signed (twos-complement) integers.                                 */
-static inline SIMD_CFUNC simd_short4 simd_make_short4(short x, short y, short z, short w) {
-  simd_short4 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short4 simd_make_short4(short x, short y, simd_short2 zw) {
-  simd_short4 result;
-  result.x = x;
-  result.y = y;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short4 simd_make_short4(short x, simd_short2 yz, short w) {
-  simd_short4 result;
-  result.x = x;
-  result.yz = yz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short4 simd_make_short4(simd_short2 xy, short z, short w) {
-  simd_short4 result;
-  result.xy = xy;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short4 simd_make_short4(short x, simd_short3 yzw) {
-  simd_short4 result;
-  result.x = x;
-  result.yzw = yzw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short4 simd_make_short4(simd_short2 xy, simd_short2 zw) {
-  simd_short4 result;
-  result.xy = xy;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short4 simd_make_short4(simd_short3 xyz, short w) {
-  simd_short4 result;
-  result.xyz = xyz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of four 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short4 simd_make_short4(short other) {
-  simd_short4 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 16-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_short4 simd_make_short4_undef(short other) {
-  simd_short4 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short4 simd_make_short4(simd_short2 other) {
-  simd_short4 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 16-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_short4 simd_make_short4_undef(simd_short2 other) {
-  simd_short4 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short4 simd_make_short4(simd_short3 other) {
-  simd_short4 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 16-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_short4 simd_make_short4_undef(simd_short3 other) {
-  simd_short4 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_short4 simd_make_short4(simd_short4 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short4 simd_make_short4(simd_short8 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short4 simd_make_short4(simd_short16 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short4 simd_make_short4(simd_short32 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short8 simd_make_short8(simd_short4 lo, simd_short4 hi) {
-  simd_short8 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short8 simd_make_short8(short other) {
-  simd_short8 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 16-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_short8 simd_make_short8_undef(short other) {
-  simd_short8 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short8 simd_make_short8(simd_short2 other) {
-  simd_short8 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 16-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_short8 simd_make_short8_undef(simd_short2 other) {
-  simd_short8 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short8 simd_make_short8(simd_short3 other) {
-  simd_short8 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 16-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_short8 simd_make_short8_undef(simd_short3 other) {
-  simd_short8 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short8 simd_make_short8(simd_short4 other) {
-  simd_short8 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 16-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_short8 simd_make_short8_undef(simd_short4 other) {
-  simd_short8 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_short8 simd_make_short8(simd_short8 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of eight 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short8 simd_make_short8(simd_short16 other) {
-  return simd_make_short8(other.lo);
-}
-
-/*! @abstract Truncates `other` to form a vector of eight 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short8 simd_make_short8(simd_short32 other) {
-  return simd_make_short8(other.lo);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixteen 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short16 simd_make_short16(simd_short8 lo, simd_short8 hi) {
-  simd_short16 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short16 simd_make_short16(short other) {
-  simd_short16 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 16-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_short16 simd_make_short16_undef(short other) {
-  simd_short16 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short16 simd_make_short16(simd_short2 other) {
-  simd_short16 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 16-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_short16 simd_make_short16_undef(simd_short2 other) {
-  simd_short16 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short16 simd_make_short16(simd_short3 other) {
-  simd_short16 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 16-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_short16 simd_make_short16_undef(simd_short3 other) {
-  simd_short16 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short16 simd_make_short16(simd_short4 other) {
-  simd_short16 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 16-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_short16 simd_make_short16_undef(simd_short4 other) {
-  simd_short16 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short16 simd_make_short16(simd_short8 other) {
-  simd_short16 result = 0;
-  result.lo = simd_make_short8(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 16-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_short16 simd_make_short16_undef(simd_short8 other) {
-  simd_short16 result;
-  result.lo = simd_make_short8(other);
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_short16 simd_make_short16(simd_short16 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of sixteen 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_short16 simd_make_short16(simd_short32 other) {
-  return simd_make_short16(other.lo);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of thirty-two
- *  16-bit signed (twos-complement) integers.                                 */
-static inline SIMD_CFUNC simd_short32 simd_make_short32(simd_short16 lo, simd_short16 hi) {
-  simd_short32 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short32 simd_make_short32(short other) {
-  simd_short32 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 16-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_short32 simd_make_short32_undef(short other) {
-  simd_short32 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short32 simd_make_short32(simd_short2 other) {
-  simd_short32 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 16-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_short32 simd_make_short32_undef(simd_short2 other) {
-  simd_short32 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short32 simd_make_short32(simd_short3 other) {
-  simd_short32 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 16-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_short32 simd_make_short32_undef(simd_short3 other) {
-  simd_short32 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short32 simd_make_short32(simd_short4 other) {
-  simd_short32 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 16-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_short32 simd_make_short32_undef(simd_short4 other) {
-  simd_short32 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short32 simd_make_short32(simd_short8 other) {
-  simd_short32 result = 0;
-  result.lo = simd_make_short16(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 16-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_short32 simd_make_short32_undef(simd_short8 other) {
-  simd_short32 result;
-  result.lo = simd_make_short16(other);
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_short32 simd_make_short32(simd_short16 other) {
-  simd_short32 result = 0;
-  result.lo = simd_make_short16(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 16-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_short32 simd_make_short32_undef(simd_short16 other) {
-  simd_short32 result;
-  result.lo = simd_make_short16(other);
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_short32 simd_make_short32(simd_short32 other) {
-  return other;
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort2 simd_make_ushort2(unsigned short x, unsigned short y) {
-  simd_ushort2 result;
-  result.x = x;
-  result.y = y;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of two 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort2 simd_make_ushort2(unsigned short other) {
-  simd_ushort2 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of two 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort2 simd_make_ushort2_undef(unsigned short other) {
-  simd_ushort2 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_ushort2 simd_make_ushort2(simd_ushort2 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort2 simd_make_ushort2(simd_ushort3 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort2 simd_make_ushort2(simd_ushort4 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort2 simd_make_ushort2(simd_ushort8 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort2 simd_make_ushort2(simd_ushort16 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort2 simd_make_ushort2(simd_ushort32 other) {
-  return other.xy;
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort3 simd_make_ushort3(unsigned short x, unsigned short y, unsigned short z) {
-  simd_ushort3 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort3 simd_make_ushort3(unsigned short x, simd_ushort2 yz) {
-  simd_ushort3 result;
-  result.x = x;
-  result.yz = yz;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort3 simd_make_ushort3(simd_ushort2 xy, unsigned short z) {
-  simd_ushort3 result;
-  result.xy = xy;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of three 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort3 simd_make_ushort3(unsigned short other) {
-  simd_ushort3 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort3 simd_make_ushort3_undef(unsigned short other) {
-  simd_ushort3 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of three 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort3 simd_make_ushort3(simd_ushort2 other) {
-  simd_ushort3 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort3 simd_make_ushort3_undef(simd_ushort2 other) {
-  simd_ushort3 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_ushort3 simd_make_ushort3(simd_ushort3 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort3 simd_make_ushort3(simd_ushort4 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort3 simd_make_ushort3(simd_ushort8 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort3 simd_make_ushort3(simd_ushort16 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort3 simd_make_ushort3(simd_ushort32 other) {
-  return other.xyz;
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  16-bit unsigned integers.                                                 */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w) {
-  simd_ushort4 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4(unsigned short x, unsigned short y, simd_ushort2 zw) {
-  simd_ushort4 result;
-  result.x = x;
-  result.y = y;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4(unsigned short x, simd_ushort2 yz, unsigned short w) {
-  simd_ushort4 result;
-  result.x = x;
-  result.yz = yz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4(simd_ushort2 xy, unsigned short z, unsigned short w) {
-  simd_ushort4 result;
-  result.xy = xy;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4(unsigned short x, simd_ushort3 yzw) {
-  simd_ushort4 result;
-  result.x = x;
-  result.yzw = yzw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4(simd_ushort2 xy, simd_ushort2 zw) {
-  simd_ushort4 result;
-  result.xy = xy;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4(simd_ushort3 xyz, unsigned short w) {
-  simd_ushort4 result;
-  result.xyz = xyz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of four 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4(unsigned short other) {
-  simd_ushort4 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4_undef(unsigned short other) {
-  simd_ushort4 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4(simd_ushort2 other) {
-  simd_ushort4 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4_undef(simd_ushort2 other) {
-  simd_ushort4 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4(simd_ushort3 other) {
-  simd_ushort4 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4_undef(simd_ushort3 other) {
-  simd_ushort4 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4(simd_ushort4 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4(simd_ushort8 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4(simd_ushort16 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort4 simd_make_ushort4(simd_ushort32 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort8 simd_make_ushort8(simd_ushort4 lo, simd_ushort4 hi) {
-  simd_ushort8 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort8 simd_make_ushort8(unsigned short other) {
-  simd_ushort8 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort8 simd_make_ushort8_undef(unsigned short other) {
-  simd_ushort8 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort8 simd_make_ushort8(simd_ushort2 other) {
-  simd_ushort8 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort8 simd_make_ushort8_undef(simd_ushort2 other) {
-  simd_ushort8 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort8 simd_make_ushort8(simd_ushort3 other) {
-  simd_ushort8 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort8 simd_make_ushort8_undef(simd_ushort3 other) {
-  simd_ushort8 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort8 simd_make_ushort8(simd_ushort4 other) {
-  simd_ushort8 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort8 simd_make_ushort8_undef(simd_ushort4 other) {
-  simd_ushort8 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_ushort8 simd_make_ushort8(simd_ushort8 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of eight 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort8 simd_make_ushort8(simd_ushort16 other) {
-  return simd_make_ushort8(other.lo);
-}
-
-/*! @abstract Truncates `other` to form a vector of eight 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort8 simd_make_ushort8(simd_ushort32 other) {
-  return simd_make_ushort8(other.lo);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixteen 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort16 simd_make_ushort16(simd_ushort8 lo, simd_ushort8 hi) {
-  simd_ushort16 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort16 simd_make_ushort16(unsigned short other) {
-  simd_ushort16 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort16 simd_make_ushort16_undef(unsigned short other) {
-  simd_ushort16 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort16 simd_make_ushort16(simd_ushort2 other) {
-  simd_ushort16 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort16 simd_make_ushort16_undef(simd_ushort2 other) {
-  simd_ushort16 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort16 simd_make_ushort16(simd_ushort3 other) {
-  simd_ushort16 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort16 simd_make_ushort16_undef(simd_ushort3 other) {
-  simd_ushort16 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort16 simd_make_ushort16(simd_ushort4 other) {
-  simd_ushort16 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort16 simd_make_ushort16_undef(simd_ushort4 other) {
-  simd_ushort16 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort16 simd_make_ushort16(simd_ushort8 other) {
-  simd_ushort16 result = 0;
-  result.lo = simd_make_ushort8(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort16 simd_make_ushort16_undef(simd_ushort8 other) {
-  simd_ushort16 result;
-  result.lo = simd_make_ushort8(other);
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_ushort16 simd_make_ushort16(simd_ushort16 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of sixteen 16-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ushort16 simd_make_ushort16(simd_ushort32 other) {
-  return simd_make_ushort16(other.lo);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of thirty-two
- *  16-bit unsigned integers.                                                 */
-static inline SIMD_CFUNC simd_ushort32 simd_make_ushort32(simd_ushort16 lo, simd_ushort16 hi) {
-  simd_ushort32 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort32 simd_make_ushort32(unsigned short other) {
-  simd_ushort32 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort32 simd_make_ushort32_undef(unsigned short other) {
-  simd_ushort32 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort32 simd_make_ushort32(simd_ushort2 other) {
-  simd_ushort32 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort32 simd_make_ushort32_undef(simd_ushort2 other) {
-  simd_ushort32 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort32 simd_make_ushort32(simd_ushort3 other) {
-  simd_ushort32 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort32 simd_make_ushort32_undef(simd_ushort3 other) {
-  simd_ushort32 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort32 simd_make_ushort32(simd_ushort4 other) {
-  simd_ushort32 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort32 simd_make_ushort32_undef(simd_ushort4 other) {
-  simd_ushort32 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort32 simd_make_ushort32(simd_ushort8 other) {
-  simd_ushort32 result = 0;
-  result.lo = simd_make_ushort16(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort32 simd_make_ushort32_undef(simd_ushort8 other) {
-  simd_ushort32 result;
-  result.lo = simd_make_ushort16(other);
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of thirty-two 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ushort32 simd_make_ushort32(simd_ushort16 other) {
-  simd_ushort32 result = 0;
-  result.lo = simd_make_ushort16(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ushort32 simd_make_ushort32_undef(simd_ushort16 other) {
-  simd_ushort32 result;
-  result.lo = simd_make_ushort16(other);
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_ushort32 simd_make_ushort32(simd_ushort32 other) {
-  return other;
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int2 simd_make_int2(int x, int y) {
-  simd_int2 result;
-  result.x = x;
-  result.y = y;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of two 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int2 simd_make_int2(int other) {
-  simd_int2 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of two 32-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_int2 simd_make_int2_undef(int other) {
-  simd_int2 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_int2 simd_make_int2(simd_int2 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 32-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_int2 simd_make_int2(simd_int3 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 32-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_int2 simd_make_int2(simd_int4 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 32-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_int2 simd_make_int2(simd_int8 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 32-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_int2 simd_make_int2(simd_int16 other) {
-  return other.xy;
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_int3 simd_make_int3(int x, int y, int z) {
-  simd_int3 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_int3 simd_make_int3(int x, simd_int2 yz) {
-  simd_int3 result;
-  result.x = x;
-  result.yz = yz;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_int3 simd_make_int3(simd_int2 xy, int z) {
-  simd_int3 result;
-  result.xy = xy;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of three 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int3 simd_make_int3(int other) {
-  simd_int3 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 32-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_int3 simd_make_int3_undef(int other) {
-  simd_int3 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of three 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int3 simd_make_int3(simd_int2 other) {
-  simd_int3 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 32-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_int3 simd_make_int3_undef(simd_int2 other) {
-  simd_int3 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_int3 simd_make_int3(simd_int3 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int3 simd_make_int3(simd_int4 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int3 simd_make_int3(simd_int8 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int3 simd_make_int3(simd_int16 other) {
-  return other.xyz;
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  32-bit signed (twos-complement) integers.                                 */
-static inline SIMD_CFUNC simd_int4 simd_make_int4(int x, int y, int z, int w) {
-  simd_int4 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_int4 simd_make_int4(int x, int y, simd_int2 zw) {
-  simd_int4 result;
-  result.x = x;
-  result.y = y;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_int4 simd_make_int4(int x, simd_int2 yz, int w) {
-  simd_int4 result;
-  result.x = x;
-  result.yz = yz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_int4 simd_make_int4(simd_int2 xy, int z, int w) {
-  simd_int4 result;
-  result.xy = xy;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_int4 simd_make_int4(int x, simd_int3 yzw) {
-  simd_int4 result;
-  result.x = x;
-  result.yzw = yzw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_int4 simd_make_int4(simd_int2 xy, simd_int2 zw) {
-  simd_int4 result;
-  result.xy = xy;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_int4 simd_make_int4(simd_int3 xyz, int w) {
-  simd_int4 result;
-  result.xyz = xyz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of four 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int4 simd_make_int4(int other) {
-  simd_int4 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 32-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_int4 simd_make_int4_undef(int other) {
-  simd_int4 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int4 simd_make_int4(simd_int2 other) {
-  simd_int4 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 32-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_int4 simd_make_int4_undef(simd_int2 other) {
-  simd_int4 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int4 simd_make_int4(simd_int3 other) {
-  simd_int4 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 32-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_int4 simd_make_int4_undef(simd_int3 other) {
-  simd_int4 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_int4 simd_make_int4(simd_int4 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int4 simd_make_int4(simd_int8 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int4 simd_make_int4(simd_int16 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_int8 simd_make_int8(simd_int4 lo, simd_int4 hi) {
-  simd_int8 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int8 simd_make_int8(int other) {
-  simd_int8 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_int8 simd_make_int8_undef(int other) {
-  simd_int8 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int8 simd_make_int8(simd_int2 other) {
-  simd_int8 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_int8 simd_make_int8_undef(simd_int2 other) {
-  simd_int8 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int8 simd_make_int8(simd_int3 other) {
-  simd_int8 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_int8 simd_make_int8_undef(simd_int3 other) {
-  simd_int8 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int8 simd_make_int8(simd_int4 other) {
-  simd_int8 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_int8 simd_make_int8_undef(simd_int4 other) {
-  simd_int8 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_int8 simd_make_int8(simd_int8 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of eight 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int8 simd_make_int8(simd_int16 other) {
-  return simd_make_int8(other.lo);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixteen 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_int16 simd_make_int16(simd_int8 lo, simd_int8 hi) {
-  simd_int16 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int16 simd_make_int16(int other) {
-  simd_int16 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_int16 simd_make_int16_undef(int other) {
-  simd_int16 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int16 simd_make_int16(simd_int2 other) {
-  simd_int16 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_int16 simd_make_int16_undef(simd_int2 other) {
-  simd_int16 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int16 simd_make_int16(simd_int3 other) {
-  simd_int16 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_int16 simd_make_int16_undef(simd_int3 other) {
-  simd_int16 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int16 simd_make_int16(simd_int4 other) {
-  simd_int16 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_int16 simd_make_int16_undef(simd_int4 other) {
-  simd_int16 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_int16 simd_make_int16(simd_int8 other) {
-  simd_int16 result = 0;
-  result.lo = simd_make_int8(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-static inline SIMD_CFUNC simd_int16 simd_make_int16_undef(simd_int8 other) {
-  simd_int16 result;
-  result.lo = simd_make_int8(other);
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_int16 simd_make_int16(simd_int16 other) {
-  return other;
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint2 simd_make_uint2(unsigned int x, unsigned int y) {
-  simd_uint2 result;
-  result.x = x;
-  result.y = y;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of two 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint2 simd_make_uint2(unsigned int other) {
-  simd_uint2 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of two 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint2 simd_make_uint2_undef(unsigned int other) {
-  simd_uint2 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_uint2 simd_make_uint2(simd_uint2 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint2 simd_make_uint2(simd_uint3 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint2 simd_make_uint2(simd_uint4 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint2 simd_make_uint2(simd_uint8 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint2 simd_make_uint2(simd_uint16 other) {
-  return other.xy;
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint3 simd_make_uint3(unsigned int x, unsigned int y, unsigned int z) {
-  simd_uint3 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint3 simd_make_uint3(unsigned int x, simd_uint2 yz) {
-  simd_uint3 result;
-  result.x = x;
-  result.yz = yz;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint3 simd_make_uint3(simd_uint2 xy, unsigned int z) {
-  simd_uint3 result;
-  result.xy = xy;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of three 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint3 simd_make_uint3(unsigned int other) {
-  simd_uint3 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint3 simd_make_uint3_undef(unsigned int other) {
-  simd_uint3 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of three 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint3 simd_make_uint3(simd_uint2 other) {
-  simd_uint3 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint3 simd_make_uint3_undef(simd_uint2 other) {
-  simd_uint3 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_uint3 simd_make_uint3(simd_uint3 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint3 simd_make_uint3(simd_uint4 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint3 simd_make_uint3(simd_uint8 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint3 simd_make_uint3(simd_uint16 other) {
-  return other.xyz;
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  32-bit unsigned integers.                                                 */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4(unsigned int x, unsigned int y, unsigned int z, unsigned int w) {
-  simd_uint4 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4(unsigned int x, unsigned int y, simd_uint2 zw) {
-  simd_uint4 result;
-  result.x = x;
-  result.y = y;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4(unsigned int x, simd_uint2 yz, unsigned int w) {
-  simd_uint4 result;
-  result.x = x;
-  result.yz = yz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4(simd_uint2 xy, unsigned int z, unsigned int w) {
-  simd_uint4 result;
-  result.xy = xy;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4(unsigned int x, simd_uint3 yzw) {
-  simd_uint4 result;
-  result.x = x;
-  result.yzw = yzw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4(simd_uint2 xy, simd_uint2 zw) {
-  simd_uint4 result;
-  result.xy = xy;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4(simd_uint3 xyz, unsigned int w) {
-  simd_uint4 result;
-  result.xyz = xyz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of four 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4(unsigned int other) {
-  simd_uint4 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4_undef(unsigned int other) {
-  simd_uint4 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4(simd_uint2 other) {
-  simd_uint4 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4_undef(simd_uint2 other) {
-  simd_uint4 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4(simd_uint3 other) {
-  simd_uint4 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4_undef(simd_uint3 other) {
-  simd_uint4 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4(simd_uint4 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4(simd_uint8 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint4 simd_make_uint4(simd_uint16 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint8 simd_make_uint8(simd_uint4 lo, simd_uint4 hi) {
-  simd_uint8 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint8 simd_make_uint8(unsigned int other) {
-  simd_uint8 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint8 simd_make_uint8_undef(unsigned int other) {
-  simd_uint8 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint8 simd_make_uint8(simd_uint2 other) {
-  simd_uint8 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint8 simd_make_uint8_undef(simd_uint2 other) {
-  simd_uint8 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint8 simd_make_uint8(simd_uint3 other) {
-  simd_uint8 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint8 simd_make_uint8_undef(simd_uint3 other) {
-  simd_uint8 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint8 simd_make_uint8(simd_uint4 other) {
-  simd_uint8 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint8 simd_make_uint8_undef(simd_uint4 other) {
-  simd_uint8 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_uint8 simd_make_uint8(simd_uint8 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of eight 32-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_uint8 simd_make_uint8(simd_uint16 other) {
-  return simd_make_uint8(other.lo);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixteen 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint16 simd_make_uint16(simd_uint8 lo, simd_uint8 hi) {
-  simd_uint16 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint16 simd_make_uint16(unsigned int other) {
-  simd_uint16 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint16 simd_make_uint16_undef(unsigned int other) {
-  simd_uint16 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint16 simd_make_uint16(simd_uint2 other) {
-  simd_uint16 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint16 simd_make_uint16_undef(simd_uint2 other) {
-  simd_uint16 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint16 simd_make_uint16(simd_uint3 other) {
-  simd_uint16 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint16 simd_make_uint16_undef(simd_uint3 other) {
-  simd_uint16 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint16 simd_make_uint16(simd_uint4 other) {
-  simd_uint16 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint16 simd_make_uint16_undef(simd_uint4 other) {
-  simd_uint16 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_uint16 simd_make_uint16(simd_uint8 other) {
-  simd_uint16 result = 0;
-  result.lo = simd_make_uint8(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_uint16 simd_make_uint16_undef(simd_uint8 other) {
-  simd_uint16 result;
-  result.lo = simd_make_uint8(other);
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_uint16 simd_make_uint16(simd_uint16 other) {
-  return other;
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float2 simd_make_float2(float x, float y) {
-  simd_float2 result;
-  result.x = x;
-  result.y = y;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of two 32-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_float2 simd_make_float2(float other) {
-  simd_float2 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of two 32-bit floating-point
- *  numbers. The contents of the newly-created vector lanes are unspecified.  */
-static inline SIMD_CFUNC simd_float2 simd_make_float2_undef(float other) {
-  simd_float2 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_float2 simd_make_float2(simd_float2 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 32-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_float2 simd_make_float2(simd_float3 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 32-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_float2 simd_make_float2(simd_float4 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 32-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_float2 simd_make_float2(simd_float8 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 32-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_float2 simd_make_float2(simd_float16 other) {
-  return other.xy;
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float3 simd_make_float3(float x, float y, float z) {
-  simd_float3 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float3 simd_make_float3(float x, simd_float2 yz) {
-  simd_float3 result;
-  result.x = x;
-  result.yz = yz;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float3 simd_make_float3(simd_float2 xy, float z) {
-  simd_float3 result;
-  result.xy = xy;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of three 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float3 simd_make_float3(float other) {
-  simd_float3 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 32-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_float3 simd_make_float3_undef(float other) {
-  simd_float3 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of three 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float3 simd_make_float3(simd_float2 other) {
-  simd_float3 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 32-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_float3 simd_make_float3_undef(simd_float2 other) {
-  simd_float3 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_float3 simd_make_float3(simd_float3 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 32-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_float3 simd_make_float3(simd_float4 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 32-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_float3 simd_make_float3(simd_float8 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 32-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_float3 simd_make_float3(simd_float16 other) {
-  return other.xyz;
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  32-bit floating-point numbers.                                            */
-static inline SIMD_CFUNC simd_float4 simd_make_float4(float x, float y, float z, float w) {
-  simd_float4 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float4 simd_make_float4(float x, float y, simd_float2 zw) {
-  simd_float4 result;
-  result.x = x;
-  result.y = y;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float4 simd_make_float4(float x, simd_float2 yz, float w) {
-  simd_float4 result;
-  result.x = x;
-  result.yz = yz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float4 simd_make_float4(simd_float2 xy, float z, float w) {
-  simd_float4 result;
-  result.xy = xy;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float4 simd_make_float4(float x, simd_float3 yzw) {
-  simd_float4 result;
-  result.x = x;
-  result.yzw = yzw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float4 simd_make_float4(simd_float2 xy, simd_float2 zw) {
-  simd_float4 result;
-  result.xy = xy;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float4 simd_make_float4(simd_float3 xyz, float w) {
-  simd_float4 result;
-  result.xyz = xyz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of four 32-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_float4 simd_make_float4(float other) {
-  simd_float4 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 32-bit floating-point
- *  numbers. The contents of the newly-created vector lanes are unspecified.  */
-static inline SIMD_CFUNC simd_float4 simd_make_float4_undef(float other) {
-  simd_float4 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 32-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_float4 simd_make_float4(simd_float2 other) {
-  simd_float4 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 32-bit floating-point
- *  numbers. The contents of the newly-created vector lanes are unspecified.  */
-static inline SIMD_CFUNC simd_float4 simd_make_float4_undef(simd_float2 other) {
-  simd_float4 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 32-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_float4 simd_make_float4(simd_float3 other) {
-  simd_float4 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 32-bit floating-point
- *  numbers. The contents of the newly-created vector lanes are unspecified.  */
-static inline SIMD_CFUNC simd_float4 simd_make_float4_undef(simd_float3 other) {
-  simd_float4 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_float4 simd_make_float4(simd_float4 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 32-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_float4 simd_make_float4(simd_float8 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 32-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_float4 simd_make_float4(simd_float16 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float8 simd_make_float8(simd_float4 lo, simd_float4 hi) {
-  simd_float8 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float8 simd_make_float8(float other) {
-  simd_float8 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_float8 simd_make_float8_undef(float other) {
-  simd_float8 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float8 simd_make_float8(simd_float2 other) {
-  simd_float8 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_float8 simd_make_float8_undef(simd_float2 other) {
-  simd_float8 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float8 simd_make_float8(simd_float3 other) {
-  simd_float8 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_float8 simd_make_float8_undef(simd_float3 other) {
-  simd_float8 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float8 simd_make_float8(simd_float4 other) {
-  simd_float8 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_float8 simd_make_float8_undef(simd_float4 other) {
-  simd_float8 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_float8 simd_make_float8(simd_float8 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of eight 32-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_float8 simd_make_float8(simd_float16 other) {
-  return simd_make_float8(other.lo);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixteen 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float16 simd_make_float16(simd_float8 lo, simd_float8 hi) {
-  simd_float16 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float16 simd_make_float16(float other) {
-  simd_float16 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_float16 simd_make_float16_undef(float other) {
-  simd_float16 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float16 simd_make_float16(simd_float2 other) {
-  simd_float16 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_float16 simd_make_float16_undef(simd_float2 other) {
-  simd_float16 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float16 simd_make_float16(simd_float3 other) {
-  simd_float16 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_float16 simd_make_float16_undef(simd_float3 other) {
-  simd_float16 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float16 simd_make_float16(simd_float4 other) {
-  simd_float16 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_float16 simd_make_float16_undef(simd_float4 other) {
-  simd_float16 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of sixteen 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_float16 simd_make_float16(simd_float8 other) {
-  simd_float16 result = 0;
-  result.lo = simd_make_float8(other);
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_float16 simd_make_float16_undef(simd_float8 other) {
-  simd_float16 result;
-  result.lo = simd_make_float8(other);
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_float16 simd_make_float16(simd_float16 other) {
-  return other;
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_long2 simd_make_long2(simd_long1 x, simd_long1 y) {
-  simd_long2 result;
-  result.x = x;
-  result.y = y;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of two 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_long2 simd_make_long2(simd_long1 other) {
-  simd_long2 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of two 64-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_long2 simd_make_long2_undef(simd_long1 other) {
-  simd_long2 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_long2 simd_make_long2(simd_long2 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 64-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_long2 simd_make_long2(simd_long3 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 64-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_long2 simd_make_long2(simd_long4 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 64-bit signed (twos-
- *  complement) integers.                                                     */
-static inline SIMD_CFUNC simd_long2 simd_make_long2(simd_long8 other) {
-  return other.xy;
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_long3 simd_make_long3(simd_long1 x, simd_long1 y, simd_long1 z) {
-  simd_long3 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_long3 simd_make_long3(simd_long1 x, simd_long2 yz) {
-  simd_long3 result;
-  result.x = x;
-  result.yz = yz;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_long3 simd_make_long3(simd_long2 xy, simd_long1 z) {
-  simd_long3 result;
-  result.xy = xy;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of three 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_long3 simd_make_long3(simd_long1 other) {
-  simd_long3 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 64-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_long3 simd_make_long3_undef(simd_long1 other) {
-  simd_long3 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of three 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_long3 simd_make_long3(simd_long2 other) {
-  simd_long3 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 64-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_long3 simd_make_long3_undef(simd_long2 other) {
-  simd_long3 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_long3 simd_make_long3(simd_long3 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_long3 simd_make_long3(simd_long4 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_long3 simd_make_long3(simd_long8 other) {
-  return other.xyz;
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  64-bit signed (twos-complement) integers.                                 */
-static inline SIMD_CFUNC simd_long4 simd_make_long4(simd_long1 x, simd_long1 y, simd_long1 z, simd_long1 w) {
-  simd_long4 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_long4 simd_make_long4(simd_long1 x, simd_long1 y, simd_long2 zw) {
-  simd_long4 result;
-  result.x = x;
-  result.y = y;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_long4 simd_make_long4(simd_long1 x, simd_long2 yz, simd_long1 w) {
-  simd_long4 result;
-  result.x = x;
-  result.yz = yz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_long4 simd_make_long4(simd_long2 xy, simd_long1 z, simd_long1 w) {
-  simd_long4 result;
-  result.xy = xy;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_long4 simd_make_long4(simd_long1 x, simd_long3 yzw) {
-  simd_long4 result;
-  result.x = x;
-  result.yzw = yzw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_long4 simd_make_long4(simd_long2 xy, simd_long2 zw) {
-  simd_long4 result;
-  result.xy = xy;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_long4 simd_make_long4(simd_long3 xyz, simd_long1 w) {
-  simd_long4 result;
-  result.xyz = xyz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of four 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_long4 simd_make_long4(simd_long1 other) {
-  simd_long4 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 64-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_long4 simd_make_long4_undef(simd_long1 other) {
-  simd_long4 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_long4 simd_make_long4(simd_long2 other) {
-  simd_long4 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 64-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_long4 simd_make_long4_undef(simd_long2 other) {
-  simd_long4 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_long4 simd_make_long4(simd_long3 other) {
-  simd_long4 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 64-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_long4 simd_make_long4_undef(simd_long3 other) {
-  simd_long4 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_long4 simd_make_long4(simd_long4 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_long4 simd_make_long4(simd_long8 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CFUNC simd_long8 simd_make_long8(simd_long4 lo, simd_long4 hi) {
-  simd_long8 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_long8 simd_make_long8(simd_long1 other) {
-  simd_long8 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_long8 simd_make_long8_undef(simd_long1 other) {
-  simd_long8 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_long8 simd_make_long8(simd_long2 other) {
-  simd_long8 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_long8 simd_make_long8_undef(simd_long2 other) {
-  simd_long8 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_long8 simd_make_long8(simd_long3 other) {
-  simd_long8 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_long8 simd_make_long8_undef(simd_long3 other) {
-  simd_long8 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CFUNC simd_long8 simd_make_long8(simd_long4 other) {
-  simd_long8 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_long8 simd_make_long8_undef(simd_long4 other) {
-  simd_long8 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_long8 simd_make_long8(simd_long8 other) {
-  return other;
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ulong2 simd_make_ulong2(simd_ulong1 x, simd_ulong1 y) {
-  simd_ulong2 result;
-  result.x = x;
-  result.y = y;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of two 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong2 simd_make_ulong2(simd_ulong1 other) {
-  simd_ulong2 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of two 64-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ulong2 simd_make_ulong2_undef(simd_ulong1 other) {
-  simd_ulong2 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_ulong2 simd_make_ulong2(simd_ulong2 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong2 simd_make_ulong2(simd_ulong3 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong2 simd_make_ulong2(simd_ulong4 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong2 simd_make_ulong2(simd_ulong8 other) {
-  return other.xy;
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ulong3 simd_make_ulong3(simd_ulong1 x, simd_ulong1 y, simd_ulong1 z) {
-  simd_ulong3 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ulong3 simd_make_ulong3(simd_ulong1 x, simd_ulong2 yz) {
-  simd_ulong3 result;
-  result.x = x;
-  result.yz = yz;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ulong3 simd_make_ulong3(simd_ulong2 xy, simd_ulong1 z) {
-  simd_ulong3 result;
-  result.xy = xy;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of three 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong3 simd_make_ulong3(simd_ulong1 other) {
-  simd_ulong3 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 64-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ulong3 simd_make_ulong3_undef(simd_ulong1 other) {
-  simd_ulong3 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of three 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong3 simd_make_ulong3(simd_ulong2 other) {
-  simd_ulong3 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 64-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ulong3 simd_make_ulong3_undef(simd_ulong2 other) {
-  simd_ulong3 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_ulong3 simd_make_ulong3(simd_ulong3 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong3 simd_make_ulong3(simd_ulong4 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong3 simd_make_ulong3(simd_ulong8 other) {
-  return other.xyz;
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  64-bit unsigned integers.                                                 */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4(simd_ulong1 x, simd_ulong1 y, simd_ulong1 z, simd_ulong1 w) {
-  simd_ulong4 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4(simd_ulong1 x, simd_ulong1 y, simd_ulong2 zw) {
-  simd_ulong4 result;
-  result.x = x;
-  result.y = y;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4(simd_ulong1 x, simd_ulong2 yz, simd_ulong1 w) {
-  simd_ulong4 result;
-  result.x = x;
-  result.yz = yz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4(simd_ulong2 xy, simd_ulong1 z, simd_ulong1 w) {
-  simd_ulong4 result;
-  result.xy = xy;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4(simd_ulong1 x, simd_ulong3 yzw) {
-  simd_ulong4 result;
-  result.x = x;
-  result.yzw = yzw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4(simd_ulong2 xy, simd_ulong2 zw) {
-  simd_ulong4 result;
-  result.xy = xy;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4(simd_ulong3 xyz, simd_ulong1 w) {
-  simd_ulong4 result;
-  result.xyz = xyz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of four 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4(simd_ulong1 other) {
-  simd_ulong4 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 64-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4_undef(simd_ulong1 other) {
-  simd_ulong4 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4(simd_ulong2 other) {
-  simd_ulong4 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 64-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4_undef(simd_ulong2 other) {
-  simd_ulong4 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4(simd_ulong3 other) {
-  simd_ulong4 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 64-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4_undef(simd_ulong3 other) {
-  simd_ulong4 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4(simd_ulong4 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong4 simd_make_ulong4(simd_ulong8 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CFUNC simd_ulong8 simd_make_ulong8(simd_ulong4 lo, simd_ulong4 hi) {
-  simd_ulong8 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong8 simd_make_ulong8(simd_ulong1 other) {
-  simd_ulong8 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ulong8 simd_make_ulong8_undef(simd_ulong1 other) {
-  simd_ulong8 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong8 simd_make_ulong8(simd_ulong2 other) {
-  simd_ulong8 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ulong8 simd_make_ulong8_undef(simd_ulong2 other) {
-  simd_ulong8 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong8 simd_make_ulong8(simd_ulong3 other) {
-  simd_ulong8 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ulong8 simd_make_ulong8_undef(simd_ulong3 other) {
-  simd_ulong8 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 64-bit unsigned
- *  integers.                                                                 */
-static inline SIMD_CFUNC simd_ulong8 simd_make_ulong8(simd_ulong4 other) {
-  simd_ulong8 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_ulong8 simd_make_ulong8_undef(simd_ulong4 other) {
-  simd_ulong8 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_ulong8 simd_make_ulong8(simd_ulong8 other) {
-  return other;
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double2 simd_make_double2(double x, double y) {
-  simd_double2 result;
-  result.x = x;
-  result.y = y;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of two 64-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_double2 simd_make_double2(double other) {
-  simd_double2 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of two 64-bit floating-point
- *  numbers. The contents of the newly-created vector lanes are unspecified.  */
-static inline SIMD_CFUNC simd_double2 simd_make_double2_undef(double other) {
-  simd_double2 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_double2 simd_make_double2(simd_double2 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 64-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_double2 simd_make_double2(simd_double3 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 64-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_double2 simd_make_double2(simd_double4 other) {
-  return other.xy;
-}
-
-/*! @abstract Truncates `other` to form a vector of two 64-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_double2 simd_make_double2(simd_double8 other) {
-  return other.xy;
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double3 simd_make_double3(double x, double y, double z) {
-  simd_double3 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double3 simd_make_double3(double x, simd_double2 yz) {
-  simd_double3 result;
-  result.x = x;
-  result.yz = yz;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double3 simd_make_double3(simd_double2 xy, double z) {
-  simd_double3 result;
-  result.xy = xy;
-  result.z = z;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of three 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double3 simd_make_double3(double other) {
-  simd_double3 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 64-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_double3 simd_make_double3_undef(double other) {
-  simd_double3 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of three 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double3 simd_make_double3(simd_double2 other) {
-  simd_double3 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of three 64-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_double3 simd_make_double3_undef(simd_double2 other) {
-  simd_double3 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_double3 simd_make_double3(simd_double3 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 64-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_double3 simd_make_double3(simd_double4 other) {
-  return other.xyz;
-}
-
-/*! @abstract Truncates `other` to form a vector of three 64-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_double3 simd_make_double3(simd_double8 other) {
-  return other.xyz;
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  64-bit floating-point numbers.                                            */
-static inline SIMD_CFUNC simd_double4 simd_make_double4(double x, double y, double z, double w) {
-  simd_double4 result;
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double4 simd_make_double4(double x, double y, simd_double2 zw) {
-  simd_double4 result;
-  result.x = x;
-  result.y = y;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double4 simd_make_double4(double x, simd_double2 yz, double w) {
-  simd_double4 result;
-  result.x = x;
-  result.yz = yz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double4 simd_make_double4(simd_double2 xy, double z, double w) {
-  simd_double4 result;
-  result.xy = xy;
-  result.z = z;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double4 simd_make_double4(double x, simd_double3 yzw) {
-  simd_double4 result;
-  result.x = x;
-  result.yzw = yzw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double4 simd_make_double4(simd_double2 xy, simd_double2 zw) {
-  simd_double4 result;
-  result.xy = xy;
-  result.zw = zw;
-  return result;
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double4 simd_make_double4(simd_double3 xyz, double w) {
-  simd_double4 result;
-  result.xyz = xyz;
-  result.w = w;
-  return result;
-}
-  
-/*! @abstract Zero-extends `other` to form a vector of four 64-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_double4 simd_make_double4(double other) {
-  simd_double4 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 64-bit floating-point
- *  numbers. The contents of the newly-created vector lanes are unspecified.  */
-static inline SIMD_CFUNC simd_double4 simd_make_double4_undef(double other) {
-  simd_double4 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 64-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_double4 simd_make_double4(simd_double2 other) {
-  simd_double4 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 64-bit floating-point
- *  numbers. The contents of the newly-created vector lanes are unspecified.  */
-static inline SIMD_CFUNC simd_double4 simd_make_double4_undef(simd_double2 other) {
-  simd_double4 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of four 64-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_double4 simd_make_double4(simd_double3 other) {
-  simd_double4 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of four 64-bit floating-point
- *  numbers. The contents of the newly-created vector lanes are unspecified.  */
-static inline SIMD_CFUNC simd_double4 simd_make_double4_undef(simd_double3 other) {
-  simd_double4 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_double4 simd_make_double4(simd_double4 other) {
-  return other;
-}
-
-/*! @abstract Truncates `other` to form a vector of four 64-bit floating-
- *  point numbers.                                                            */
-static inline SIMD_CFUNC simd_double4 simd_make_double4(simd_double8 other) {
-  return other.xyzw;
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double8 simd_make_double8(simd_double4 lo, simd_double4 hi) {
-  simd_double8 result;
-  result.lo = lo;
-  result.hi = hi;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double8 simd_make_double8(double other) {
-  simd_double8 result = 0;
-  result.x = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_double8 simd_make_double8_undef(double other) {
-  simd_double8 result;
-  result.x = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double8 simd_make_double8(simd_double2 other) {
-  simd_double8 result = 0;
-  result.xy = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_double8 simd_make_double8_undef(simd_double2 other) {
-  simd_double8 result;
-  result.xy = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double8 simd_make_double8(simd_double3 other) {
-  simd_double8 result = 0;
-  result.xyz = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_double8 simd_make_double8_undef(simd_double3 other) {
-  simd_double8 result;
-  result.xyz = other;
-  return result;
-}
-
-/*! @abstract Zero-extends `other` to form a vector of eight 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CFUNC simd_double8 simd_make_double8(simd_double4 other) {
-  simd_double8 result = 0;
-  result.xyzw = other;
-  return result;
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-static inline SIMD_CFUNC simd_double8 simd_make_double8_undef(simd_double4 other) {
-  simd_double8 result;
-  result.xyzw = other;
-  return result;
-}
-
-/*! @abstract Returns `other` unmodified. This function is a convenience for
- *  templated and autogenerated code.                                         */
-static inline SIMD_CFUNC simd_double8 simd_make_double8(simd_double8 other) {
-  return other;
-}
-
-#ifdef __cplusplus
-} /* extern "C" */
-
-namespace simd {
-/*! @abstract Concatenates `x` and `y` to form a vector of two 8-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CPPFUNC char2 make_char2(char x, char y) {
- return ::simd_make_char2(x, y);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of two
- *  8-bit signed (twos-complement) integers.                                  */
-template <typename typeN> static SIMD_CPPFUNC char2 make_char2(typeN other) {
-  return ::simd_make_char2(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of two 8-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC char2 make_char2_undef(typeN other) {
-  return ::simd_make_char2_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC char3 make_char3(char x, char y, char z) {
- return ::simd_make_char3(x, y, z);
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC char3 make_char3(char x, char2 yz) {
- return ::simd_make_char3(x, yz);
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC char3 make_char3(char2 xy, char z) {
- return ::simd_make_char3(xy, z);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of three
- *  8-bit signed (twos-complement) integers.                                  */
-template <typename typeN> static SIMD_CPPFUNC char3 make_char3(typeN other) {
-  return ::simd_make_char3(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of three 8-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC char3 make_char3_undef(typeN other) {
-  return ::simd_make_char3_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  8-bit signed (twos-complement) integers.                                  */
-static inline SIMD_CPPFUNC char4 make_char4(char x, char y, char z, char w) {
- return ::simd_make_char4(x, y, z, w);
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC char4 make_char4(char x, char y, char2 zw) {
- return ::simd_make_char4(x, y, zw);
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC char4 make_char4(char x, char2 yz, char w) {
- return ::simd_make_char4(x, yz, w);
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC char4 make_char4(char2 xy, char z, char w) {
- return ::simd_make_char4(xy, z, w);
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC char4 make_char4(char x, char3 yzw) {
- return ::simd_make_char4(x, yzw);
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC char4 make_char4(char2 xy, char2 zw) {
- return ::simd_make_char4(xy, zw);
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC char4 make_char4(char3 xyz, char w) {
- return ::simd_make_char4(xyz, w);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of four
- *  8-bit signed (twos-complement) integers.                                  */
-template <typename typeN> static SIMD_CPPFUNC char4 make_char4(typeN other) {
-  return ::simd_make_char4(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of four 8-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC char4 make_char4_undef(typeN other) {
-  return ::simd_make_char4_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC char8 make_char8(char4 lo, char4 hi) {
- return ::simd_make_char8(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of eight
- *  8-bit signed (twos-complement) integers.                                  */
-template <typename typeN> static SIMD_CPPFUNC char8 make_char8(typeN other) {
-  return ::simd_make_char8(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 8-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC char8 make_char8_undef(typeN other) {
-  return ::simd_make_char8_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixteen 8-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC char16 make_char16(char8 lo, char8 hi) {
- return ::simd_make_char16(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of sixteen
- *  8-bit signed (twos-complement) integers.                                  */
-template <typename typeN> static SIMD_CPPFUNC char16 make_char16(typeN other) {
-  return ::simd_make_char16(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-template <typename typeN> static SIMD_CPPFUNC char16 make_char16_undef(typeN other) {
-  return ::simd_make_char16_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of thirty-two
- *  8-bit signed (twos-complement) integers.                                  */
-static inline SIMD_CPPFUNC char32 make_char32(char16 lo, char16 hi) {
- return ::simd_make_char32(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of thirty-
- *  two 8-bit signed (twos-complement) integers.                              */
-template <typename typeN> static SIMD_CPPFUNC char32 make_char32(typeN other) {
-  return ::simd_make_char32(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-template <typename typeN> static SIMD_CPPFUNC char32 make_char32_undef(typeN other) {
-  return ::simd_make_char32_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixty-four
- *  8-bit signed (twos-complement) integers.                                  */
-static inline SIMD_CPPFUNC char64 make_char64(char32 lo, char32 hi) {
- return ::simd_make_char64(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of sixty-
- *  four 8-bit signed (twos-complement) integers.                             */
-template <typename typeN> static SIMD_CPPFUNC char64 make_char64(typeN other) {
-  return ::simd_make_char64(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-template <typename typeN> static SIMD_CPPFUNC char64 make_char64_undef(typeN other) {
-  return ::simd_make_char64_undef(other);
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uchar2 make_uchar2(unsigned char x, unsigned char y) {
- return ::simd_make_uchar2(x, y);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of two
- *  8-bit unsigned integers.                                                  */
-template <typename typeN> static SIMD_CPPFUNC uchar2 make_uchar2(typeN other) {
-  return ::simd_make_uchar2(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of two 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC uchar2 make_uchar2_undef(typeN other) {
-  return ::simd_make_uchar2_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uchar3 make_uchar3(unsigned char x, unsigned char y, unsigned char z) {
- return ::simd_make_uchar3(x, y, z);
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uchar3 make_uchar3(unsigned char x, uchar2 yz) {
- return ::simd_make_uchar3(x, yz);
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uchar3 make_uchar3(uchar2 xy, unsigned char z) {
- return ::simd_make_uchar3(xy, z);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of three
- *  8-bit unsigned integers.                                                  */
-template <typename typeN> static SIMD_CPPFUNC uchar3 make_uchar3(typeN other) {
-  return ::simd_make_uchar3(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of three 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC uchar3 make_uchar3_undef(typeN other) {
-  return ::simd_make_uchar3_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  8-bit unsigned integers.                                                  */
-static inline SIMD_CPPFUNC uchar4 make_uchar4(unsigned char x, unsigned char y, unsigned char z, unsigned char w) {
- return ::simd_make_uchar4(x, y, z, w);
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uchar4 make_uchar4(unsigned char x, unsigned char y, uchar2 zw) {
- return ::simd_make_uchar4(x, y, zw);
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uchar4 make_uchar4(unsigned char x, uchar2 yz, unsigned char w) {
- return ::simd_make_uchar4(x, yz, w);
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uchar4 make_uchar4(uchar2 xy, unsigned char z, unsigned char w) {
- return ::simd_make_uchar4(xy, z, w);
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uchar4 make_uchar4(unsigned char x, uchar3 yzw) {
- return ::simd_make_uchar4(x, yzw);
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uchar4 make_uchar4(uchar2 xy, uchar2 zw) {
- return ::simd_make_uchar4(xy, zw);
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uchar4 make_uchar4(uchar3 xyz, unsigned char w) {
- return ::simd_make_uchar4(xyz, w);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of four
- *  8-bit unsigned integers.                                                  */
-template <typename typeN> static SIMD_CPPFUNC uchar4 make_uchar4(typeN other) {
-  return ::simd_make_uchar4(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of four 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC uchar4 make_uchar4_undef(typeN other) {
-  return ::simd_make_uchar4_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uchar8 make_uchar8(uchar4 lo, uchar4 hi) {
- return ::simd_make_uchar8(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of eight
- *  8-bit unsigned integers.                                                  */
-template <typename typeN> static SIMD_CPPFUNC uchar8 make_uchar8(typeN other) {
-  return ::simd_make_uchar8(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC uchar8 make_uchar8_undef(typeN other) {
-  return ::simd_make_uchar8_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixteen 8-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uchar16 make_uchar16(uchar8 lo, uchar8 hi) {
- return ::simd_make_uchar16(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of sixteen
- *  8-bit unsigned integers.                                                  */
-template <typename typeN> static SIMD_CPPFUNC uchar16 make_uchar16(typeN other) {
-  return ::simd_make_uchar16(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC uchar16 make_uchar16_undef(typeN other) {
-  return ::simd_make_uchar16_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of thirty-two
- *  8-bit unsigned integers.                                                  */
-static inline SIMD_CPPFUNC uchar32 make_uchar32(uchar16 lo, uchar16 hi) {
- return ::simd_make_uchar32(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of thirty-
- *  two 8-bit unsigned integers.                                              */
-template <typename typeN> static SIMD_CPPFUNC uchar32 make_uchar32(typeN other) {
-  return ::simd_make_uchar32(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC uchar32 make_uchar32_undef(typeN other) {
-  return ::simd_make_uchar32_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixty-four
- *  8-bit unsigned integers.                                                  */
-static inline SIMD_CPPFUNC uchar64 make_uchar64(uchar32 lo, uchar32 hi) {
- return ::simd_make_uchar64(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of sixty-
- *  four 8-bit unsigned integers.                                             */
-template <typename typeN> static SIMD_CPPFUNC uchar64 make_uchar64(typeN other) {
-  return ::simd_make_uchar64(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of sixty-four 8-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC uchar64 make_uchar64_undef(typeN other) {
-  return ::simd_make_uchar64_undef(other);
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 16-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CPPFUNC short2 make_short2(short x, short y) {
- return ::simd_make_short2(x, y);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of two
- *  16-bit signed (twos-complement) integers.                                 */
-template <typename typeN> static SIMD_CPPFUNC short2 make_short2(typeN other) {
-  return ::simd_make_short2(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of two 16-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC short2 make_short2_undef(typeN other) {
-  return ::simd_make_short2_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC short3 make_short3(short x, short y, short z) {
- return ::simd_make_short3(x, y, z);
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC short3 make_short3(short x, short2 yz) {
- return ::simd_make_short3(x, yz);
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC short3 make_short3(short2 xy, short z) {
- return ::simd_make_short3(xy, z);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of three
- *  16-bit signed (twos-complement) integers.                                 */
-template <typename typeN> static SIMD_CPPFUNC short3 make_short3(typeN other) {
-  return ::simd_make_short3(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of three 16-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC short3 make_short3_undef(typeN other) {
-  return ::simd_make_short3_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  16-bit signed (twos-complement) integers.                                 */
-static inline SIMD_CPPFUNC short4 make_short4(short x, short y, short z, short w) {
- return ::simd_make_short4(x, y, z, w);
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC short4 make_short4(short x, short y, short2 zw) {
- return ::simd_make_short4(x, y, zw);
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC short4 make_short4(short x, short2 yz, short w) {
- return ::simd_make_short4(x, yz, w);
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC short4 make_short4(short2 xy, short z, short w) {
- return ::simd_make_short4(xy, z, w);
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC short4 make_short4(short x, short3 yzw) {
- return ::simd_make_short4(x, yzw);
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC short4 make_short4(short2 xy, short2 zw) {
- return ::simd_make_short4(xy, zw);
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC short4 make_short4(short3 xyz, short w) {
- return ::simd_make_short4(xyz, w);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of four
- *  16-bit signed (twos-complement) integers.                                 */
-template <typename typeN> static SIMD_CPPFUNC short4 make_short4(typeN other) {
-  return ::simd_make_short4(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of four 16-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC short4 make_short4_undef(typeN other) {
-  return ::simd_make_short4_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC short8 make_short8(short4 lo, short4 hi) {
- return ::simd_make_short8(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of eight
- *  16-bit signed (twos-complement) integers.                                 */
-template <typename typeN> static SIMD_CPPFUNC short8 make_short8(typeN other) {
-  return ::simd_make_short8(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 16-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC short8 make_short8_undef(typeN other) {
-  return ::simd_make_short8_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixteen 16-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC short16 make_short16(short8 lo, short8 hi) {
- return ::simd_make_short16(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of sixteen
- *  16-bit signed (twos-complement) integers.                                 */
-template <typename typeN> static SIMD_CPPFUNC short16 make_short16(typeN other) {
-  return ::simd_make_short16(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 16-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-template <typename typeN> static SIMD_CPPFUNC short16 make_short16_undef(typeN other) {
-  return ::simd_make_short16_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of thirty-two
- *  16-bit signed (twos-complement) integers.                                 */
-static inline SIMD_CPPFUNC short32 make_short32(short16 lo, short16 hi) {
- return ::simd_make_short32(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of thirty-
- *  two 16-bit signed (twos-complement) integers.                             */
-template <typename typeN> static SIMD_CPPFUNC short32 make_short32(typeN other) {
-  return ::simd_make_short32(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 16-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-template <typename typeN> static SIMD_CPPFUNC short32 make_short32_undef(typeN other) {
-  return ::simd_make_short32_undef(other);
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ushort2 make_ushort2(unsigned short x, unsigned short y) {
- return ::simd_make_ushort2(x, y);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of two
- *  16-bit unsigned integers.                                                 */
-template <typename typeN> static SIMD_CPPFUNC ushort2 make_ushort2(typeN other) {
-  return ::simd_make_ushort2(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of two 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC ushort2 make_ushort2_undef(typeN other) {
-  return ::simd_make_ushort2_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ushort3 make_ushort3(unsigned short x, unsigned short y, unsigned short z) {
- return ::simd_make_ushort3(x, y, z);
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ushort3 make_ushort3(unsigned short x, ushort2 yz) {
- return ::simd_make_ushort3(x, yz);
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ushort3 make_ushort3(ushort2 xy, unsigned short z) {
- return ::simd_make_ushort3(xy, z);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of three
- *  16-bit unsigned integers.                                                 */
-template <typename typeN> static SIMD_CPPFUNC ushort3 make_ushort3(typeN other) {
-  return ::simd_make_ushort3(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of three 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC ushort3 make_ushort3_undef(typeN other) {
-  return ::simd_make_ushort3_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  16-bit unsigned integers.                                                 */
-static inline SIMD_CPPFUNC ushort4 make_ushort4(unsigned short x, unsigned short y, unsigned short z, unsigned short w) {
- return ::simd_make_ushort4(x, y, z, w);
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ushort4 make_ushort4(unsigned short x, unsigned short y, ushort2 zw) {
- return ::simd_make_ushort4(x, y, zw);
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ushort4 make_ushort4(unsigned short x, ushort2 yz, unsigned short w) {
- return ::simd_make_ushort4(x, yz, w);
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ushort4 make_ushort4(ushort2 xy, unsigned short z, unsigned short w) {
- return ::simd_make_ushort4(xy, z, w);
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ushort4 make_ushort4(unsigned short x, ushort3 yzw) {
- return ::simd_make_ushort4(x, yzw);
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ushort4 make_ushort4(ushort2 xy, ushort2 zw) {
- return ::simd_make_ushort4(xy, zw);
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ushort4 make_ushort4(ushort3 xyz, unsigned short w) {
- return ::simd_make_ushort4(xyz, w);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of four
- *  16-bit unsigned integers.                                                 */
-template <typename typeN> static SIMD_CPPFUNC ushort4 make_ushort4(typeN other) {
-  return ::simd_make_ushort4(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of four 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC ushort4 make_ushort4_undef(typeN other) {
-  return ::simd_make_ushort4_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ushort8 make_ushort8(ushort4 lo, ushort4 hi) {
- return ::simd_make_ushort8(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of eight
- *  16-bit unsigned integers.                                                 */
-template <typename typeN> static SIMD_CPPFUNC ushort8 make_ushort8(typeN other) {
-  return ::simd_make_ushort8(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC ushort8 make_ushort8_undef(typeN other) {
-  return ::simd_make_ushort8_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixteen 16-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ushort16 make_ushort16(ushort8 lo, ushort8 hi) {
- return ::simd_make_ushort16(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of sixteen
- *  16-bit unsigned integers.                                                 */
-template <typename typeN> static SIMD_CPPFUNC ushort16 make_ushort16(typeN other) {
-  return ::simd_make_ushort16(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC ushort16 make_ushort16_undef(typeN other) {
-  return ::simd_make_ushort16_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of thirty-two
- *  16-bit unsigned integers.                                                 */
-static inline SIMD_CPPFUNC ushort32 make_ushort32(ushort16 lo, ushort16 hi) {
- return ::simd_make_ushort32(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of thirty-
- *  two 16-bit unsigned integers.                                             */
-template <typename typeN> static SIMD_CPPFUNC ushort32 make_ushort32(typeN other) {
-  return ::simd_make_ushort32(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of thirty-two 16-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC ushort32 make_ushort32_undef(typeN other) {
-  return ::simd_make_ushort32_undef(other);
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 32-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CPPFUNC int2 make_int2(int x, int y) {
- return ::simd_make_int2(x, y);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of two
- *  32-bit signed (twos-complement) integers.                                 */
-template <typename typeN> static SIMD_CPPFUNC int2 make_int2(typeN other) {
-  return ::simd_make_int2(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of two 32-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC int2 make_int2_undef(typeN other) {
-  return ::simd_make_int2_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC int3 make_int3(int x, int y, int z) {
- return ::simd_make_int3(x, y, z);
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC int3 make_int3(int x, int2 yz) {
- return ::simd_make_int3(x, yz);
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC int3 make_int3(int2 xy, int z) {
- return ::simd_make_int3(xy, z);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of three
- *  32-bit signed (twos-complement) integers.                                 */
-template <typename typeN> static SIMD_CPPFUNC int3 make_int3(typeN other) {
-  return ::simd_make_int3(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of three 32-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC int3 make_int3_undef(typeN other) {
-  return ::simd_make_int3_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  32-bit signed (twos-complement) integers.                                 */
-static inline SIMD_CPPFUNC int4 make_int4(int x, int y, int z, int w) {
- return ::simd_make_int4(x, y, z, w);
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC int4 make_int4(int x, int y, int2 zw) {
- return ::simd_make_int4(x, y, zw);
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC int4 make_int4(int x, int2 yz, int w) {
- return ::simd_make_int4(x, yz, w);
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC int4 make_int4(int2 xy, int z, int w) {
- return ::simd_make_int4(xy, z, w);
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC int4 make_int4(int x, int3 yzw) {
- return ::simd_make_int4(x, yzw);
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC int4 make_int4(int2 xy, int2 zw) {
- return ::simd_make_int4(xy, zw);
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC int4 make_int4(int3 xyz, int w) {
- return ::simd_make_int4(xyz, w);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of four
- *  32-bit signed (twos-complement) integers.                                 */
-template <typename typeN> static SIMD_CPPFUNC int4 make_int4(typeN other) {
-  return ::simd_make_int4(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of four 32-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC int4 make_int4_undef(typeN other) {
-  return ::simd_make_int4_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC int8 make_int8(int4 lo, int4 hi) {
- return ::simd_make_int8(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of eight
- *  32-bit signed (twos-complement) integers.                                 */
-template <typename typeN> static SIMD_CPPFUNC int8 make_int8(typeN other) {
-  return ::simd_make_int8(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC int8 make_int8_undef(typeN other) {
-  return ::simd_make_int8_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixteen 32-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC int16 make_int16(int8 lo, int8 hi) {
- return ::simd_make_int16(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of sixteen
- *  32-bit signed (twos-complement) integers.                                 */
-template <typename typeN> static SIMD_CPPFUNC int16 make_int16(typeN other) {
-  return ::simd_make_int16(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit signed
- *  (twos-complement) integers. The contents of the newly-created vector
- *  lanes are unspecified.                                                    */
-template <typename typeN> static SIMD_CPPFUNC int16 make_int16_undef(typeN other) {
-  return ::simd_make_int16_undef(other);
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uint2 make_uint2(unsigned int x, unsigned int y) {
- return ::simd_make_uint2(x, y);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of two
- *  32-bit unsigned integers.                                                 */
-template <typename typeN> static SIMD_CPPFUNC uint2 make_uint2(typeN other) {
-  return ::simd_make_uint2(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of two 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC uint2 make_uint2_undef(typeN other) {
-  return ::simd_make_uint2_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uint3 make_uint3(unsigned int x, unsigned int y, unsigned int z) {
- return ::simd_make_uint3(x, y, z);
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uint3 make_uint3(unsigned int x, uint2 yz) {
- return ::simd_make_uint3(x, yz);
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uint3 make_uint3(uint2 xy, unsigned int z) {
- return ::simd_make_uint3(xy, z);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of three
- *  32-bit unsigned integers.                                                 */
-template <typename typeN> static SIMD_CPPFUNC uint3 make_uint3(typeN other) {
-  return ::simd_make_uint3(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of three 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC uint3 make_uint3_undef(typeN other) {
-  return ::simd_make_uint3_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  32-bit unsigned integers.                                                 */
-static inline SIMD_CPPFUNC uint4 make_uint4(unsigned int x, unsigned int y, unsigned int z, unsigned int w) {
- return ::simd_make_uint4(x, y, z, w);
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uint4 make_uint4(unsigned int x, unsigned int y, uint2 zw) {
- return ::simd_make_uint4(x, y, zw);
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uint4 make_uint4(unsigned int x, uint2 yz, unsigned int w) {
- return ::simd_make_uint4(x, yz, w);
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uint4 make_uint4(uint2 xy, unsigned int z, unsigned int w) {
- return ::simd_make_uint4(xy, z, w);
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uint4 make_uint4(unsigned int x, uint3 yzw) {
- return ::simd_make_uint4(x, yzw);
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uint4 make_uint4(uint2 xy, uint2 zw) {
- return ::simd_make_uint4(xy, zw);
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uint4 make_uint4(uint3 xyz, unsigned int w) {
- return ::simd_make_uint4(xyz, w);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of four
- *  32-bit unsigned integers.                                                 */
-template <typename typeN> static SIMD_CPPFUNC uint4 make_uint4(typeN other) {
-  return ::simd_make_uint4(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of four 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC uint4 make_uint4_undef(typeN other) {
-  return ::simd_make_uint4_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uint8 make_uint8(uint4 lo, uint4 hi) {
- return ::simd_make_uint8(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of eight
- *  32-bit unsigned integers.                                                 */
-template <typename typeN> static SIMD_CPPFUNC uint8 make_uint8(typeN other) {
-  return ::simd_make_uint8(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC uint8 make_uint8_undef(typeN other) {
-  return ::simd_make_uint8_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixteen 32-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC uint16 make_uint16(uint8 lo, uint8 hi) {
- return ::simd_make_uint16(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of sixteen
- *  32-bit unsigned integers.                                                 */
-template <typename typeN> static SIMD_CPPFUNC uint16 make_uint16(typeN other) {
-  return ::simd_make_uint16(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC uint16 make_uint16_undef(typeN other) {
-  return ::simd_make_uint16_undef(other);
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC float2 make_float2(float x, float y) {
- return ::simd_make_float2(x, y);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of two
- *  32-bit floating-point numbers.                                            */
-template <typename typeN> static SIMD_CPPFUNC float2 make_float2(typeN other) {
-  return ::simd_make_float2(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of two 32-bit floating-point
- *  numbers. The contents of the newly-created vector lanes are unspecified.  */
-template <typename typeN> static SIMD_CPPFUNC float2 make_float2_undef(typeN other) {
-  return ::simd_make_float2_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC float3 make_float3(float x, float y, float z) {
- return ::simd_make_float3(x, y, z);
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC float3 make_float3(float x, float2 yz) {
- return ::simd_make_float3(x, yz);
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC float3 make_float3(float2 xy, float z) {
- return ::simd_make_float3(xy, z);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of three
- *  32-bit floating-point numbers.                                            */
-template <typename typeN> static SIMD_CPPFUNC float3 make_float3(typeN other) {
-  return ::simd_make_float3(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of three 32-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC float3 make_float3_undef(typeN other) {
-  return ::simd_make_float3_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  32-bit floating-point numbers.                                            */
-static inline SIMD_CPPFUNC float4 make_float4(float x, float y, float z, float w) {
- return ::simd_make_float4(x, y, z, w);
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC float4 make_float4(float x, float y, float2 zw) {
- return ::simd_make_float4(x, y, zw);
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC float4 make_float4(float x, float2 yz, float w) {
- return ::simd_make_float4(x, yz, w);
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC float4 make_float4(float2 xy, float z, float w) {
- return ::simd_make_float4(xy, z, w);
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC float4 make_float4(float x, float3 yzw) {
- return ::simd_make_float4(x, yzw);
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC float4 make_float4(float2 xy, float2 zw) {
- return ::simd_make_float4(xy, zw);
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC float4 make_float4(float3 xyz, float w) {
- return ::simd_make_float4(xyz, w);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of four
- *  32-bit floating-point numbers.                                            */
-template <typename typeN> static SIMD_CPPFUNC float4 make_float4(typeN other) {
-  return ::simd_make_float4(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of four 32-bit floating-point
- *  numbers. The contents of the newly-created vector lanes are unspecified.  */
-template <typename typeN> static SIMD_CPPFUNC float4 make_float4_undef(typeN other) {
-  return ::simd_make_float4_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC float8 make_float8(float4 lo, float4 hi) {
- return ::simd_make_float8(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of eight
- *  32-bit floating-point numbers.                                            */
-template <typename typeN> static SIMD_CPPFUNC float8 make_float8(typeN other) {
-  return ::simd_make_float8(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 32-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC float8 make_float8_undef(typeN other) {
-  return ::simd_make_float8_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of sixteen 32-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC float16 make_float16(float8 lo, float8 hi) {
- return ::simd_make_float16(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of sixteen
- *  32-bit floating-point numbers.                                            */
-template <typename typeN> static SIMD_CPPFUNC float16 make_float16(typeN other) {
-  return ::simd_make_float16(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of sixteen 32-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC float16 make_float16_undef(typeN other) {
-  return ::simd_make_float16_undef(other);
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 64-bit signed
- *  (twos-complement) integers.                                               */
-static inline SIMD_CPPFUNC long2 make_long2(long1 x, long1 y) {
- return ::simd_make_long2(x, y);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of two
- *  64-bit signed (twos-complement) integers.                                 */
-template <typename typeN> static SIMD_CPPFUNC long2 make_long2(typeN other) {
-  return ::simd_make_long2(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of two 64-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC long2 make_long2_undef(typeN other) {
-  return ::simd_make_long2_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC long3 make_long3(long1 x, long1 y, long1 z) {
- return ::simd_make_long3(x, y, z);
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC long3 make_long3(long1 x, long2 yz) {
- return ::simd_make_long3(x, yz);
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC long3 make_long3(long2 xy, long1 z) {
- return ::simd_make_long3(xy, z);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of three
- *  64-bit signed (twos-complement) integers.                                 */
-template <typename typeN> static SIMD_CPPFUNC long3 make_long3(typeN other) {
-  return ::simd_make_long3(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of three 64-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC long3 make_long3_undef(typeN other) {
-  return ::simd_make_long3_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  64-bit signed (twos-complement) integers.                                 */
-static inline SIMD_CPPFUNC long4 make_long4(long1 x, long1 y, long1 z, long1 w) {
- return ::simd_make_long4(x, y, z, w);
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC long4 make_long4(long1 x, long1 y, long2 zw) {
- return ::simd_make_long4(x, y, zw);
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC long4 make_long4(long1 x, long2 yz, long1 w) {
- return ::simd_make_long4(x, yz, w);
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC long4 make_long4(long2 xy, long1 z, long1 w) {
- return ::simd_make_long4(xy, z, w);
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC long4 make_long4(long1 x, long3 yzw) {
- return ::simd_make_long4(x, yzw);
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC long4 make_long4(long2 xy, long2 zw) {
- return ::simd_make_long4(xy, zw);
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC long4 make_long4(long3 xyz, long1 w) {
- return ::simd_make_long4(xyz, w);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of four
- *  64-bit signed (twos-complement) integers.                                 */
-template <typename typeN> static SIMD_CPPFUNC long4 make_long4(typeN other) {
-  return ::simd_make_long4(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of four 64-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC long4 make_long4_undef(typeN other) {
-  return ::simd_make_long4_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 64-bit
- *  signed (twos-complement) integers.                                        */
-static inline SIMD_CPPFUNC long8 make_long8(long4 lo, long4 hi) {
- return ::simd_make_long8(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of eight
- *  64-bit signed (twos-complement) integers.                                 */
-template <typename typeN> static SIMD_CPPFUNC long8 make_long8(typeN other) {
-  return ::simd_make_long8(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit signed (twos-
- *  complement) integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC long8 make_long8_undef(typeN other) {
-  return ::simd_make_long8_undef(other);
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ulong2 make_ulong2(ulong1 x, ulong1 y) {
- return ::simd_make_ulong2(x, y);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of two
- *  64-bit unsigned integers.                                                 */
-template <typename typeN> static SIMD_CPPFUNC ulong2 make_ulong2(typeN other) {
-  return ::simd_make_ulong2(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of two 64-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC ulong2 make_ulong2_undef(typeN other) {
-  return ::simd_make_ulong2_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ulong3 make_ulong3(ulong1 x, ulong1 y, ulong1 z) {
- return ::simd_make_ulong3(x, y, z);
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ulong3 make_ulong3(ulong1 x, ulong2 yz) {
- return ::simd_make_ulong3(x, yz);
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ulong3 make_ulong3(ulong2 xy, ulong1 z) {
- return ::simd_make_ulong3(xy, z);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of three
- *  64-bit unsigned integers.                                                 */
-template <typename typeN> static SIMD_CPPFUNC ulong3 make_ulong3(typeN other) {
-  return ::simd_make_ulong3(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of three 64-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC ulong3 make_ulong3_undef(typeN other) {
-  return ::simd_make_ulong3_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  64-bit unsigned integers.                                                 */
-static inline SIMD_CPPFUNC ulong4 make_ulong4(ulong1 x, ulong1 y, ulong1 z, ulong1 w) {
- return ::simd_make_ulong4(x, y, z, w);
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ulong4 make_ulong4(ulong1 x, ulong1 y, ulong2 zw) {
- return ::simd_make_ulong4(x, y, zw);
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ulong4 make_ulong4(ulong1 x, ulong2 yz, ulong1 w) {
- return ::simd_make_ulong4(x, yz, w);
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ulong4 make_ulong4(ulong2 xy, ulong1 z, ulong1 w) {
- return ::simd_make_ulong4(xy, z, w);
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ulong4 make_ulong4(ulong1 x, ulong3 yzw) {
- return ::simd_make_ulong4(x, yzw);
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ulong4 make_ulong4(ulong2 xy, ulong2 zw) {
- return ::simd_make_ulong4(xy, zw);
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ulong4 make_ulong4(ulong3 xyz, ulong1 w) {
- return ::simd_make_ulong4(xyz, w);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of four
- *  64-bit unsigned integers.                                                 */
-template <typename typeN> static SIMD_CPPFUNC ulong4 make_ulong4(typeN other) {
-  return ::simd_make_ulong4(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of four 64-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC ulong4 make_ulong4_undef(typeN other) {
-  return ::simd_make_ulong4_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 64-bit
- *  unsigned integers.                                                        */
-static inline SIMD_CPPFUNC ulong8 make_ulong8(ulong4 lo, ulong4 hi) {
- return ::simd_make_ulong8(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of eight
- *  64-bit unsigned integers.                                                 */
-template <typename typeN> static SIMD_CPPFUNC ulong8 make_ulong8(typeN other) {
-  return ::simd_make_ulong8(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit unsigned
- *  integers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC ulong8 make_ulong8_undef(typeN other) {
-  return ::simd_make_ulong8_undef(other);
-}
-
-/*! @abstract Concatenates `x` and `y` to form a vector of two 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC double2 make_double2(double x, double y) {
- return ::simd_make_double2(x, y);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of two
- *  64-bit floating-point numbers.                                            */
-template <typename typeN> static SIMD_CPPFUNC double2 make_double2(typeN other) {
-  return ::simd_make_double2(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of two 64-bit floating-point
- *  numbers. The contents of the newly-created vector lanes are unspecified.  */
-template <typename typeN> static SIMD_CPPFUNC double2 make_double2_undef(typeN other) {
-  return ::simd_make_double2_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y` and `z` to form a vector of three 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC double3 make_double3(double x, double y, double z) {
- return ::simd_make_double3(x, y, z);
-}
-  
-/*! @abstract Concatenates `x` and `yz` to form a vector of three 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC double3 make_double3(double x, double2 yz) {
- return ::simd_make_double3(x, yz);
-}
-  
-/*! @abstract Concatenates `xy` and `z` to form a vector of three 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC double3 make_double3(double2 xy, double z) {
- return ::simd_make_double3(xy, z);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of three
- *  64-bit floating-point numbers.                                            */
-template <typename typeN> static SIMD_CPPFUNC double3 make_double3(typeN other) {
-  return ::simd_make_double3(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of three 64-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC double3 make_double3_undef(typeN other) {
-  return ::simd_make_double3_undef(other);
-}
-
-/*! @abstract Concatenates `x`, `y`, `z` and `w` to form a vector of four
- *  64-bit floating-point numbers.                                            */
-static inline SIMD_CPPFUNC double4 make_double4(double x, double y, double z, double w) {
- return ::simd_make_double4(x, y, z, w);
-}
-  
-/*! @abstract Concatenates `x`, `y` and `zw` to form a vector of four 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC double4 make_double4(double x, double y, double2 zw) {
- return ::simd_make_double4(x, y, zw);
-}
-  
-/*! @abstract Concatenates `x`, `yz` and `w` to form a vector of four 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC double4 make_double4(double x, double2 yz, double w) {
- return ::simd_make_double4(x, yz, w);
-}
-  
-/*! @abstract Concatenates `xy`, `z` and `w` to form a vector of four 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC double4 make_double4(double2 xy, double z, double w) {
- return ::simd_make_double4(xy, z, w);
-}
-  
-/*! @abstract Concatenates `x` and `yzw` to form a vector of four 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC double4 make_double4(double x, double3 yzw) {
- return ::simd_make_double4(x, yzw);
-}
-  
-/*! @abstract Concatenates `xy` and `zw` to form a vector of four 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC double4 make_double4(double2 xy, double2 zw) {
- return ::simd_make_double4(xy, zw);
-}
-  
-/*! @abstract Concatenates `xyz` and `w` to form a vector of four 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC double4 make_double4(double3 xyz, double w) {
- return ::simd_make_double4(xyz, w);
-}
-  
-/*! @abstract Truncates or zero-extends `other` to form a vector of four
- *  64-bit floating-point numbers.                                            */
-template <typename typeN> static SIMD_CPPFUNC double4 make_double4(typeN other) {
-  return ::simd_make_double4(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of four 64-bit floating-point
- *  numbers. The contents of the newly-created vector lanes are unspecified.  */
-template <typename typeN> static SIMD_CPPFUNC double4 make_double4_undef(typeN other) {
-  return ::simd_make_double4_undef(other);
-}
-
-/*! @abstract Concatenates `lo` and `hi` to form a vector of eight 64-bit
- *  floating-point numbers.                                                   */
-static inline SIMD_CPPFUNC double8 make_double8(double4 lo, double4 hi) {
- return ::simd_make_double8(lo, hi);
-}
-
-/*! @abstract Truncates or zero-extends `other` to form a vector of eight
- *  64-bit floating-point numbers.                                            */
-template <typename typeN> static SIMD_CPPFUNC double8 make_double8(typeN other) {
-  return ::simd_make_double8(other);
-}
-  
-/*! @abstract Extends `other` to form a vector of eight 64-bit floating-
- *  point numbers. The contents of the newly-created vector lanes are
- *  unspecified.                                                              */
-template <typename typeN> static SIMD_CPPFUNC double8 make_double8_undef(typeN other) {
-  return ::simd_make_double8_undef(other);
-}
-
-} /* namespace simd */
-#endif /* __cplusplus */
-#endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */
-#endif /* SIMD_VECTOR_CONSTRUCTORS */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/spawn.h b/lib/libc/include/x86_64-macos.10-none/spawn.h
deleted file mode 100644
index 8441df3abe..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/spawn.h
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * Copyright (c) 2006, 2010 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-
-
-#ifndef _SPAWN_H_
-#define _SPAWN_H_
-
-/*
- * [SPN] Support for _POSIX_SPAWN
- */
-
-#include <sys/cdefs.h>
-#include <_types.h>
-#include <sys/spawn.h> /* shared types */
-
-#include <Availability.h>
-
-/*
- * [SPN] Inclusion of the <spawn.h> header may make visible symbols defined
- * in the <sched.h>, <signal.h>, and <sys/types.h> headers.
- */
-#include <sys/_types/_pid_t.h>
-#include <sys/_types/_sigset_t.h>
-#include <sys/_types/_mode_t.h>
-
-/*
- * Opaque types for use with posix_spawn() family functions.  Internals are
- * not defined, and should not be accessed directly.  Types are defined as
- * mandated by POSIX.
- */
-typedef  void *posix_spawnattr_t;
-typedef  void *posix_spawn_file_actions_t;
-
-__BEGIN_DECLS
-/*
- * gcc under c99 mode won't compile "[ __restrict]" by itself.  As a workaround,
- * a dummy argument name is added.
- */
-
-int     posix_spawn(pid_t * __restrict, const char * __restrict,
-    const posix_spawn_file_actions_t *,
-    const posix_spawnattr_t * __restrict,
-    char *const __argv[__restrict],
-    char *const __envp[__restrict]) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnp(pid_t * __restrict, const char * __restrict,
-    const posix_spawn_file_actions_t *,
-    const posix_spawnattr_t * __restrict,
-    char *const __argv[__restrict],
-    char *const __envp[__restrict]) __API_AVAILABLE(macos(10.5), ios(2.0));
-
-int     posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *, int) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *, int,
-    int) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawn_file_actions_addopen(
-	posix_spawn_file_actions_t * __restrict, int,
-	const char * __restrict, int, mode_t) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawn_file_actions_init(posix_spawn_file_actions_t *) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_destroy(posix_spawnattr_t *) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_getsigdefault(const posix_spawnattr_t * __restrict,
-    sigset_t * __restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_getflags(const posix_spawnattr_t * __restrict,
-    short * __restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_getpgroup(const posix_spawnattr_t * __restrict,
-    pid_t * __restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_getsigmask(const posix_spawnattr_t * __restrict,
-    sigset_t * __restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_init(posix_spawnattr_t *) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setsigdefault(posix_spawnattr_t * __restrict,
-    const sigset_t * __restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setflags(posix_spawnattr_t *, short) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setpgroup(posix_spawnattr_t *, pid_t) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setsigmask(posix_spawnattr_t * __restrict,
-    const sigset_t * __restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-#if 0   /* _POSIX_PRIORITY_SCHEDULING [PS] : not supported */
-int     posix_spawnattr_setschedparam(posix_spawnattr_t * __restrict,
-    const struct sched_param * __restrict);
-int     posix_spawnattr_setschedpolicy(posix_spawnattr_t *, int);
-int     posix_spawnattr_getschedparam(const posix_spawnattr_t * __restrict,
-    struct sched_param * __restrict);
-int     posix_spawnattr_getschedpolicy(const posix_spawnattr_t * __restrict,
-    int * __restrict);
-#endif  /* 0 */
-
-__END_DECLS
-
-#if     !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/*
- * Darwin-specific extensions below
- */
-#include <mach/exception_types.h>
-#include <mach/machine.h>
-#include <mach/port.h>
-
-#include <sys/_types/_size_t.h>
-
-__BEGIN_DECLS
-
-int     posix_spawnattr_getbinpref_np(const posix_spawnattr_t * __restrict,
-    size_t, cpu_type_t *__restrict, size_t *__restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setauditsessionport_np(posix_spawnattr_t * __restrict,
-    mach_port_t) __API_AVAILABLE(macos(10.6), ios(3.2));
-
-int     posix_spawnattr_setbinpref_np(posix_spawnattr_t * __restrict,
-    size_t, cpu_type_t *__restrict, size_t *__restrict) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setexceptionports_np(posix_spawnattr_t * __restrict,
-    exception_mask_t, mach_port_t,
-    exception_behavior_t, thread_state_flavor_t) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setspecialport_np(posix_spawnattr_t * __restrict,
-    mach_port_t, int) __API_AVAILABLE(macos(10.5), ios(2.0)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawnattr_setsuidcredport_np(posix_spawnattr_t * __restrict, mach_port_t) __API_UNAVAILABLE(ios, macos);
-
-int     posix_spawn_file_actions_addinherit_np(posix_spawn_file_actions_t *,
-    int) __API_AVAILABLE(macos(10.7), ios(4.3)) __API_UNAVAILABLE(watchos, tvos);
-
-int     posix_spawn_file_actions_addchdir_np(posix_spawn_file_actions_t *,
-    const char * __restrict) __API_AVAILABLE(macos(10.15)) __API_UNAVAILABLE(ios, tvos, watchos);
-
-int     posix_spawn_file_actions_addfchdir_np(posix_spawn_file_actions_t *,
-    int) __API_AVAILABLE(macos(10.15)) __API_UNAVAILABLE(ios, tvos, watchos);
-
-__END_DECLS
-
-#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-#endif  /* _SPAWN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/string.h b/lib/libc/include/x86_64-macos.10-none/string.h
deleted file mode 100644
index bca8f8c881..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/string.h
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * Copyright (c) 2000, 2007, 2010 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_LICENSE_HEADER_END@
- */
-/*-
- * Copyright (c) 1990, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)string.h	8.1 (Berkeley) 6/2/93
- */
-
-#ifndef _STRING_H_
-#define	_STRING_H_
-
-#include <_types.h>
-#include <sys/cdefs.h>
-#include <Availability.h>
-#include <sys/_types/_size_t.h>
-#include <sys/_types/_null.h>
-
-/* ANSI-C */
-
-__BEGIN_DECLS
-void	*memchr(const void *__s, int __c, size_t __n);
-int	 memcmp(const void *__s1, const void *__s2, size_t __n);
-void	*memcpy(void *__dst, const void *__src, size_t __n);
-void	*memmove(void *__dst, const void *__src, size_t __len);
-void	*memset(void *__b, int __c, size_t __len);
-char	*strcat(char *__s1, const char *__s2);
-char	*strchr(const char *__s, int __c);
-int	 strcmp(const char *__s1, const char *__s2);
-int	 strcoll(const char *__s1, const char *__s2);
-char	*strcpy(char *__dst, const char *__src);
-size_t	 strcspn(const char *__s, const char *__charset);
-char	*strerror(int __errnum) __DARWIN_ALIAS(strerror);
-size_t	 strlen(const char *__s);
-char	*strncat(char *__s1, const char *__s2, size_t __n);
-int	 strncmp(const char *__s1, const char *__s2, size_t __n);
-char	*strncpy(char *__dst, const char *__src, size_t __n);
-char	*strpbrk(const char *__s, const char *__charset);
-char	*strrchr(const char *__s, int __c);
-size_t	 strspn(const char *__s, const char *__charset);
-char	*strstr(const char *__big, const char *__little);
-char	*strtok(char *__str, const char *__sep);
-size_t	 strxfrm(char *__s1, const char *__s2, size_t __n);
-__END_DECLS
-
-
-
-/* Additional functionality provided by:
- * POSIX.1c-1995,
- * POSIX.1i-1995,
- * and the omnibus ISO/IEC 9945-1: 1996
- */
-
-#if __DARWIN_C_LEVEL >= 199506L
-__BEGIN_DECLS
-char	*strtok_r(char *__str, const char *__sep, char **__lasts);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 199506L */
-
-
-
-/* Additional functionality provided by:
- * POSIX.1-2001
- */
-
-#if __DARWIN_C_LEVEL >= 200112L
-__BEGIN_DECLS
-int	 strerror_r(int __errnum, char *__strerrbuf, size_t __buflen);
-char	*strdup(const char *__s1);
-void	*memccpy(void *__dst, const void *__src, int __c, size_t __n);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 200112L */
-
-
-
-/* Additional functionality provided by:
- * POSIX.1-2008
- */
-
-#if __DARWIN_C_LEVEL >= 200809L
-__BEGIN_DECLS
-char	*stpcpy(char *__dst, const char *__src);
-char    *stpncpy(char *__dst, const char *__src, size_t __n) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-char	*strndup(const char *__s1, size_t __n) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-size_t   strnlen(const char *__s1, size_t __n) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-char	*strsignal(int __sig);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 200809L */
-
-/* C11 Annex K */
-
-#if defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__ >= 1
-#include <sys/_types/_rsize_t.h>
-#include <sys/_types/_errno_t.h>
-
-__BEGIN_DECLS
-errno_t	memset_s(void *__s, rsize_t __smax, int __c, rsize_t __n) __OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0);
-__END_DECLS
-#endif
-
-/* Darwin extensions */
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#include <sys/_types/_ssize_t.h>
-
-__BEGIN_DECLS
-void	*memmem(const void *__big, size_t __big_len, const void *__little, size_t __little_len) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-void     memset_pattern4(void *__b, const void *__pattern4, size_t __len) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_0);
-void     memset_pattern8(void *__b, const void *__pattern8, size_t __len) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_0);
-void     memset_pattern16(void *__b, const void *__pattern16, size_t __len) __OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_0);
-
-char	*strcasestr(const char *__big, const char *__little);
-char	*strnstr(const char *__big, const char *__little, size_t __len);
-size_t	 strlcat(char *__dst, const char *__source, size_t __size);
-size_t	 strlcpy(char *__dst, const char *__source, size_t __size);
-void	 strmode(int __mode, char *__bp);
-char	*strsep(char **__stringp, const char *__delim);
-
-/* SUS places swab() in unistd.h.  It is listed here for source compatibility */
-void	 swab(const void * __restrict, void * __restrict, ssize_t);
-
-__OSX_AVAILABLE(10.12.1) __IOS_AVAILABLE(10.1)
-__TVOS_AVAILABLE(10.0.1) __WATCHOS_AVAILABLE(3.1)
-int	timingsafe_bcmp(const void *__b1, const void *__b2, size_t __len);
-__END_DECLS
-
-/* Some functions historically defined in string.h were placed in strings.h
- * by SUS.  We are using "strings.h" instead of <strings.h> to avoid an issue
- * where /Developer/Headers/FlatCarbon/Strings.h could be included instead on
- * case-insensitive file systems.
- */
-#include "strings.h"
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-
-#ifdef _USE_EXTENDED_LOCALES_
-#include <xlocale/_string.h>
-#endif /* _USE_EXTENDED_LOCALES_ */
-
-#if defined (__GNUC__) && _FORTIFY_SOURCE > 0 && !defined (__cplusplus)
-/* Security checking functions.  */
-#include <secure/_string.h>
-#endif
-
-#endif /* _STRING_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_attr_t.h b/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_attr_t.h
deleted file mode 100644
index a71842cb99..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_attr_t.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _PTHREAD_ATTR_T 
-#define _PTHREAD_ATTR_T 
-#include <sys/_pthread/_pthread_types.h> /* __darwin_pthread_attr_t */
-typedef __darwin_pthread_attr_t pthread_attr_t;
-#endif  /* _PTHREAD_ATTR_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_cond_t.h b/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_cond_t.h
deleted file mode 100644
index 3eceff6274..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_cond_t.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _PTHREAD_COND_T
-#define _PTHREAD_COND_T
-#include <sys/_pthread/_pthread_types.h> /* __darwin_pthread_cond_t */
-typedef __darwin_pthread_cond_t pthread_cond_t;
-#endif /* _PTHREAD_COND_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_condattr_t.h b/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_condattr_t.h
deleted file mode 100644
index 7fd62badd7..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_condattr_t.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _PTHREAD_CONDATTR_T
-#define _PTHREAD_CONDATTR_T
-#include <sys/_pthread/_pthread_types.h> /* __darwin_pthread_condattr_t */
-typedef __darwin_pthread_condattr_t pthread_condattr_t;
-#endif /* _PTHREAD_CONDATTR_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_rwlock_t.h b/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_rwlock_t.h
deleted file mode 100644
index dc1f013f3b..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_rwlock_t.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _PTHREAD_RWLOCK_T
-#define _PTHREAD_RWLOCK_T
-#include <sys/_pthread/_pthread_types.h> /* __darwin_pthread_rwlock_t */
-typedef __darwin_pthread_rwlock_t pthread_rwlock_t;
-#endif /* _PTHREAD_RWLOCK_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_rwlockattr_t.h b/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_rwlockattr_t.h
deleted file mode 100644
index 99fda712f4..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_rwlockattr_t.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _PTHREAD_RWLOCKATTR_T
-#define _PTHREAD_RWLOCKATTR_T
-#include <sys/_pthread/_pthread_types.h> /* __darwin_pthread_rwlockattr_t */
-typedef __darwin_pthread_rwlockattr_t pthread_rwlockattr_t;
-#endif /* _PTHREAD_RWLOCKATTR_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_t.h b/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_t.h
deleted file mode 100644
index 87f42ee9aa..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_t.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _PTHREAD_T
-#define _PTHREAD_T
-#include <sys/_pthread/_pthread_types.h> /* __darwin_pthread_t */
-typedef __darwin_pthread_t pthread_t;
-#endif /* _PTHREAD_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_types.h b/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_types.h
deleted file mode 100644
index 7aa42bdff1..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/_pthread/_pthread_types.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * Copyright (c) 2003-2013 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- * 
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _SYS__PTHREAD_TYPES_H_
-#define _SYS__PTHREAD_TYPES_H_
-
-#include <sys/cdefs.h>
-
-// pthread opaque structures
-#if defined(__LP64__)
-#define __PTHREAD_SIZE__		8176
-#define __PTHREAD_ATTR_SIZE__		56
-#define __PTHREAD_MUTEXATTR_SIZE__	8
-#define __PTHREAD_MUTEX_SIZE__		56
-#define __PTHREAD_CONDATTR_SIZE__	8
-#define __PTHREAD_COND_SIZE__		40
-#define __PTHREAD_ONCE_SIZE__		8
-#define __PTHREAD_RWLOCK_SIZE__		192
-#define __PTHREAD_RWLOCKATTR_SIZE__	16
-#else // !__LP64__
-#define __PTHREAD_SIZE__		4088
-#define __PTHREAD_ATTR_SIZE__		36
-#define __PTHREAD_MUTEXATTR_SIZE__	8
-#define __PTHREAD_MUTEX_SIZE__		40
-#define __PTHREAD_CONDATTR_SIZE__	4
-#define __PTHREAD_COND_SIZE__		24
-#define __PTHREAD_ONCE_SIZE__		4
-#define __PTHREAD_RWLOCK_SIZE__		124
-#define __PTHREAD_RWLOCKATTR_SIZE__	12
-#endif // !__LP64__
-
-struct __darwin_pthread_handler_rec {
-	void (*__routine)(void *);	// Routine to call
-	void *__arg;			// Argument to pass
-	struct __darwin_pthread_handler_rec *__next;
-};
-
-struct _opaque_pthread_attr_t {
-	long __sig;
-	char __opaque[__PTHREAD_ATTR_SIZE__];
-};
-
-struct _opaque_pthread_cond_t {
-	long __sig;
-	char __opaque[__PTHREAD_COND_SIZE__];
-};
-
-struct _opaque_pthread_condattr_t {
-	long __sig;
-	char __opaque[__PTHREAD_CONDATTR_SIZE__];
-};
-
-struct _opaque_pthread_mutex_t {
-	long __sig;
-	char __opaque[__PTHREAD_MUTEX_SIZE__];
-};
-
-struct _opaque_pthread_mutexattr_t {
-	long __sig;
-	char __opaque[__PTHREAD_MUTEXATTR_SIZE__];
-};
-
-struct _opaque_pthread_once_t {
-	long __sig;
-	char __opaque[__PTHREAD_ONCE_SIZE__];
-};
-
-struct _opaque_pthread_rwlock_t {
-	long __sig;
-	char __opaque[__PTHREAD_RWLOCK_SIZE__];
-};
-
-struct _opaque_pthread_rwlockattr_t {
-	long __sig;
-	char __opaque[__PTHREAD_RWLOCKATTR_SIZE__];
-};
-
-struct _opaque_pthread_t {
-	long __sig;
-	struct __darwin_pthread_handler_rec  *__cleanup_stack;
-	char __opaque[__PTHREAD_SIZE__];
-};
-
-typedef struct _opaque_pthread_attr_t __darwin_pthread_attr_t;
-typedef struct _opaque_pthread_cond_t __darwin_pthread_cond_t;
-typedef struct _opaque_pthread_condattr_t __darwin_pthread_condattr_t;
-typedef unsigned long __darwin_pthread_key_t;
-typedef struct _opaque_pthread_mutex_t __darwin_pthread_mutex_t;
-typedef struct _opaque_pthread_mutexattr_t __darwin_pthread_mutexattr_t;
-typedef struct _opaque_pthread_once_t __darwin_pthread_once_t;
-typedef struct _opaque_pthread_rwlock_t __darwin_pthread_rwlock_t;
-typedef struct _opaque_pthread_rwlockattr_t __darwin_pthread_rwlockattr_t;
-typedef struct _opaque_pthread_t *__darwin_pthread_t;
-
-#endif // _SYS__PTHREAD_TYPES_H_
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/_select.h b/lib/libc/include/x86_64-macos.10-none/sys/_select.h
deleted file mode 100644
index 70842ca2f5..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/_select.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) 2005, 2007 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-/*
- * This is called from sys/select.h and sys/time.h for the common prototype
- * of select().  Setting _DARWIN_C_SOURCE or _DARWIN_UNLIMITED_SELECT uses
- * the version of select() that does not place a limit on the first argument
- * (nfds).  In the UNIX conformance case, values of nfds greater than
- * FD_SETSIZE will return an error of EINVAL.
- */
-#ifndef _SYS__SELECT_H_
-#define _SYS__SELECT_H_
-
-int      select(int, fd_set * __restrict, fd_set * __restrict,
-    fd_set * __restrict, struct timeval * __restrict)
-#if defined(_DARWIN_C_SOURCE) || defined(_DARWIN_UNLIMITED_SELECT)
-__DARWIN_EXTSN_C(select)
-#else /* !_DARWIN_C_SOURCE && !_DARWIN_UNLIMITED_SELECT */
-#  if defined(__LP64__) && !__DARWIN_NON_CANCELABLE
-__DARWIN_1050(select)
-#  else /* !__LP64__ || __DARWIN_NON_CANCELABLE */
-__DARWIN_ALIAS_C(select)
-#  endif /* __LP64__ && !__DARWIN_NON_CANCELABLE */
-#endif /* _DARWIN_C_SOURCE || _DARWIN_UNLIMITED_SELECT */
-;
-
-#endif /* !_SYS__SELECT_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/_types/_fd_def.h b/lib/libc/include/x86_64-macos.10-none/sys/_types/_fd_def.h
deleted file mode 100644
index ec0bad4289..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/_types/_fd_def.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _FD_SET
-#define _FD_SET
-
-#include <machine/types.h> /* __int32_t and uintptr_t */
-#include <Availability.h>
-
-/*
- * Select uses bit masks of file descriptors in longs.  These macros
- * manipulate such bit fields (the filesystem macros use chars).  The
- * extra protection here is to permit application redefinition above
- * the default size.
- */
-#ifdef FD_SETSIZE
-#define __DARWIN_FD_SETSIZE     FD_SETSIZE
-#else /* !FD_SETSIZE */
-#define __DARWIN_FD_SETSIZE     1024
-#endif /* FD_SETSIZE */
-#define __DARWIN_NBBY           8                               /* bits in a byte */
-#define __DARWIN_NFDBITS        (sizeof(__int32_t) * __DARWIN_NBBY) /* bits per mask */
-#define __DARWIN_howmany(x, y)  ((((x) % (y)) == 0) ? ((x) / (y)) : (((x) / (y)) + 1)) /* # y's == x bits? */
-
-__BEGIN_DECLS
-typedef struct fd_set {
-	__int32_t       fds_bits[__DARWIN_howmany(__DARWIN_FD_SETSIZE, __DARWIN_NFDBITS)];
-} fd_set;
-
-int __darwin_check_fd_set_overflow(int, const void *, int) __attribute__((__weak_import__));
-__END_DECLS
-
-__header_always_inline int
-__darwin_check_fd_set(int _a, const void *_b)
-{
-	if ((uintptr_t)&__darwin_check_fd_set_overflow != (uintptr_t) 0) {
-#if defined(_DARWIN_UNLIMITED_SELECT) || defined(_DARWIN_C_SOURCE)
-		return __darwin_check_fd_set_overflow(_a, _b, 1);
-#else
-		return __darwin_check_fd_set_overflow(_a, _b, 0);
-#endif
-	} else {
-		return 1;
-	}
-}
-
-/* This inline avoids argument side-effect issues with FD_ISSET() */
-__header_always_inline int
-__darwin_fd_isset(int _fd, const struct fd_set *_p)
-{
-	if (__darwin_check_fd_set(_fd, (const void *) _p)) {
-		return _p->fds_bits[(unsigned long)_fd / __DARWIN_NFDBITS] & ((__int32_t)(((unsigned long)1) << ((unsigned long)_fd % __DARWIN_NFDBITS)));
-	}
-
-	return 0;
-}
-
-__header_always_inline void
-__darwin_fd_set(int _fd, struct fd_set *const _p)
-{
-	if (__darwin_check_fd_set(_fd, (const void *) _p)) {
-		(_p->fds_bits[(unsigned long)_fd / __DARWIN_NFDBITS] |= ((__int32_t)(((unsigned long)1) << ((unsigned long)_fd % __DARWIN_NFDBITS))));
-	}
-}
-
-__header_always_inline void
-__darwin_fd_clr(int _fd, struct fd_set *const _p)
-{
-	if (__darwin_check_fd_set(_fd, (const void *) _p)) {
-		(_p->fds_bits[(unsigned long)_fd / __DARWIN_NFDBITS] &= ~((__int32_t)(((unsigned long)1) << ((unsigned long)_fd % __DARWIN_NFDBITS))));
-	}
-}
-
-
-#define __DARWIN_FD_SET(n, p)   __darwin_fd_set((n), (p))
-#define __DARWIN_FD_CLR(n, p)   __darwin_fd_clr((n), (p))
-#define __DARWIN_FD_ISSET(n, p) __darwin_fd_isset((n), (p))
-
-#if __GNUC__ > 3 || __GNUC__ == 3 && __GNUC_MINOR__ >= 3
-/*
- * Use the built-in bzero function instead of the library version so that
- * we do not pollute the namespace or introduce prototype warnings.
- */
-#define __DARWIN_FD_ZERO(p)     __builtin_bzero(p, sizeof(*(p)))
-#else
-#define __DARWIN_FD_ZERO(p)     bzero(p, sizeof(*(p)))
-#endif
-
-#define __DARWIN_FD_COPY(f, t)  bcopy(f, t, sizeof(*(f)))
-#endif /* _FD_SET */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/_types/_int8_t.h b/lib/libc/include/x86_64-macos.10-none/sys/_types/_int8_t.h
deleted file mode 100644
index 15b281d533..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/_types/_int8_t.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _INT8_T
-#define _INT8_T
-typedef __signed char           int8_t;
-#endif /* _INT8_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/_types/_ucontext.h b/lib/libc/include/x86_64-macos.10-none/sys/_types/_ucontext.h
deleted file mode 100644
index 1e563f4581..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/_types/_ucontext.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _STRUCT_UCONTEXT
-
-#include <sys/cdefs.h> /* __DARWIN_UNIX03 */
-
-#if __DARWIN_UNIX03
-#define _STRUCT_UCONTEXT        struct __darwin_ucontext
-#else /* !__DARWIN_UNIX03 */
-#define _STRUCT_UCONTEXT        struct ucontext
-#endif /* __DARWIN_UNIX03 */
-
-#include <machine/types.h> /* __darwin_size_t */
-#include <machine/_mcontext.h> /* _STRUCT_MCONTEXT */
-#include <sys/_types.h> /* __darwin_sigset_t */
-
-_STRUCT_UCONTEXT
-{
-	int                     uc_onstack;
-	__darwin_sigset_t       uc_sigmask;     /* signal mask used by this context */
-	_STRUCT_SIGALTSTACK     uc_stack;       /* stack used by this context */
-	_STRUCT_UCONTEXT        *uc_link;       /* pointer to resuming context */
-	__darwin_size_t         uc_mcsize;      /* size of the machine context passed in */
-	_STRUCT_MCONTEXT        *uc_mcontext;   /* pointer to machine specific context */
-#ifdef _XOPEN_SOURCE
-	_STRUCT_MCONTEXT        __mcontext_data;
-#endif /* _XOPEN_SOURCE */
-};
-
-/* user context */
-typedef _STRUCT_UCONTEXT        ucontext_t;     /* [???] user context */
-
-#endif /* _STRUCT_UCONTEXT */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/_types/_uintptr_t.h b/lib/libc/include/x86_64-macos.10-none/sys/_types/_uintptr_t.h
deleted file mode 100644
index 7971dbc86a..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/_types/_uintptr_t.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2003-2012 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-#ifndef _UINTPTR_T
-#define _UINTPTR_T
-typedef unsigned long           uintptr_t;
-#endif /* _UINTPTR_T */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/acl.h b/lib/libc/include/x86_64-macos.10-none/sys/acl.h
deleted file mode 100644
index dc134613d1..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/acl.h
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * Copyright (c) 2004, 2010 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
- * 
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _SYS_ACL_H
-#define _SYS_ACL_H
-
-#include <Availability.h>
-#include <sys/kauth.h>
-
-#define __DARWIN_ACL_READ_DATA			(1<<1)
-#define __DARWIN_ACL_LIST_DIRECTORY		__DARWIN_ACL_READ_DATA
-#define __DARWIN_ACL_WRITE_DATA			(1<<2)
-#define __DARWIN_ACL_ADD_FILE			__DARWIN_ACL_WRITE_DATA
-#define __DARWIN_ACL_EXECUTE			(1<<3)
-#define __DARWIN_ACL_SEARCH			__DARWIN_ACL_EXECUTE
-#define __DARWIN_ACL_DELETE			(1<<4)
-#define __DARWIN_ACL_APPEND_DATA		(1<<5)
-#define __DARWIN_ACL_ADD_SUBDIRECTORY		__DARWIN_ACL_APPEND_DATA
-#define __DARWIN_ACL_DELETE_CHILD		(1<<6)
-#define __DARWIN_ACL_READ_ATTRIBUTES		(1<<7)
-#define __DARWIN_ACL_WRITE_ATTRIBUTES		(1<<8)
-#define __DARWIN_ACL_READ_EXTATTRIBUTES		(1<<9)
-#define __DARWIN_ACL_WRITE_EXTATTRIBUTES	(1<<10)
-#define __DARWIN_ACL_READ_SECURITY		(1<<11)
-#define __DARWIN_ACL_WRITE_SECURITY		(1<<12)
-#define __DARWIN_ACL_CHANGE_OWNER		(1<<13)
-#define __DARWIN_ACL_SYNCHRONIZE		(1<<20)
-
-#define __DARWIN_ACL_EXTENDED_ALLOW		1
-#define __DARWIN_ACL_EXTENDED_DENY		2
-
-#define __DARWIN_ACL_ENTRY_INHERITED		(1<<4)
-#define __DARWIN_ACL_ENTRY_FILE_INHERIT		(1<<5)
-#define __DARWIN_ACL_ENTRY_DIRECTORY_INHERIT	(1<<6)
-#define __DARWIN_ACL_ENTRY_LIMIT_INHERIT	(1<<7)
-#define __DARWIN_ACL_ENTRY_ONLY_INHERIT		(1<<8)
-#define __DARWIN_ACL_FLAG_NO_INHERIT		(1<<17)
-
-/*
- * Implementation constants.
- *
- * The ACL_TYPE_EXTENDED binary format permits 169 entries plus
- * the ACL header in a page.  Give ourselves some room to grow;
- * this limit is arbitrary.
- */
-#define ACL_MAX_ENTRIES		128
-
-/* 23.2.2 Individual object access permissions - nonstandard */
-typedef enum {
-	ACL_READ_DATA		= __DARWIN_ACL_READ_DATA,
-	ACL_LIST_DIRECTORY	= __DARWIN_ACL_LIST_DIRECTORY,
-	ACL_WRITE_DATA		= __DARWIN_ACL_WRITE_DATA,
-	ACL_ADD_FILE		= __DARWIN_ACL_ADD_FILE,
-	ACL_EXECUTE		= __DARWIN_ACL_EXECUTE,
-	ACL_SEARCH		= __DARWIN_ACL_SEARCH,
-	ACL_DELETE		= __DARWIN_ACL_DELETE,
-	ACL_APPEND_DATA		= __DARWIN_ACL_APPEND_DATA,
-	ACL_ADD_SUBDIRECTORY	= __DARWIN_ACL_ADD_SUBDIRECTORY,
-	ACL_DELETE_CHILD	= __DARWIN_ACL_DELETE_CHILD,
-	ACL_READ_ATTRIBUTES	= __DARWIN_ACL_READ_ATTRIBUTES,
-	ACL_WRITE_ATTRIBUTES	= __DARWIN_ACL_WRITE_ATTRIBUTES,
-	ACL_READ_EXTATTRIBUTES	= __DARWIN_ACL_READ_EXTATTRIBUTES,
-	ACL_WRITE_EXTATTRIBUTES	= __DARWIN_ACL_WRITE_EXTATTRIBUTES,
-	ACL_READ_SECURITY	= __DARWIN_ACL_READ_SECURITY,
-	ACL_WRITE_SECURITY	= __DARWIN_ACL_WRITE_SECURITY,
-	ACL_CHANGE_OWNER	= __DARWIN_ACL_CHANGE_OWNER,
-	ACL_SYNCHRONIZE		= __DARWIN_ACL_SYNCHRONIZE,
-} acl_perm_t;
-
-/* 23.2.5 ACL entry tag type bits - nonstandard */
-typedef enum {
-	ACL_UNDEFINED_TAG	= 0,
-	ACL_EXTENDED_ALLOW	= __DARWIN_ACL_EXTENDED_ALLOW,
-	ACL_EXTENDED_DENY	= __DARWIN_ACL_EXTENDED_DENY
-} acl_tag_t;
-
-/* 23.2.6 Individual ACL types */
-typedef enum {
-	ACL_TYPE_EXTENDED	= 0x00000100,
-/* Posix 1003.1e types - not supported */
-	ACL_TYPE_ACCESS         = 0x00000000,
-	ACL_TYPE_DEFAULT        = 0x00000001,
-/* The following types are defined on FreeBSD/Linux - not supported */
-	ACL_TYPE_AFS            = 0x00000002,
-	ACL_TYPE_CODA           = 0x00000003,
-	ACL_TYPE_NTFS           = 0x00000004,
-	ACL_TYPE_NWFS           = 0x00000005
-} acl_type_t;
-
-/* 23.2.7 ACL qualifier constants */
-
-#define ACL_UNDEFINED_ID	NULL	/* XXX ? */
-
-/* 23.2.8 ACL Entry Constants */
-typedef enum {
-	ACL_FIRST_ENTRY		= 0,
-	ACL_NEXT_ENTRY		= -1,
-	ACL_LAST_ENTRY		= -2
-} acl_entry_id_t;
-
-/* nonstandard ACL / entry flags */
-typedef enum {
-	ACL_FLAG_DEFER_INHERIT		= (1 << 0),	/* tentative */
-	ACL_FLAG_NO_INHERIT		= __DARWIN_ACL_FLAG_NO_INHERIT,
-	ACL_ENTRY_INHERITED		= __DARWIN_ACL_ENTRY_INHERITED,
-	ACL_ENTRY_FILE_INHERIT		= __DARWIN_ACL_ENTRY_FILE_INHERIT,
-	ACL_ENTRY_DIRECTORY_INHERIT	= __DARWIN_ACL_ENTRY_DIRECTORY_INHERIT,
-	ACL_ENTRY_LIMIT_INHERIT		= __DARWIN_ACL_ENTRY_LIMIT_INHERIT,
-	ACL_ENTRY_ONLY_INHERIT		= __DARWIN_ACL_ENTRY_ONLY_INHERIT
-} acl_flag_t;
-
-/* "External" ACL types */
-
-struct _acl;
-struct _acl_entry;
-struct _acl_permset;
-struct _acl_flagset;
-
-typedef struct _acl		*acl_t;
-typedef struct _acl_entry	*acl_entry_t;
-typedef struct _acl_permset	*acl_permset_t;
-typedef struct _acl_flagset	*acl_flagset_t;
-
-typedef u_int64_t		acl_permset_mask_t;
-
-__BEGIN_DECLS
-/* 23.1.6.1 ACL Storage Management */
-extern acl_t	acl_dup(acl_t acl);
-extern int	acl_free(void *obj_p);
-extern acl_t	acl_init(int count);
-
-/* 23.1.6.2 (1) ACL Entry manipulation */
-extern int	acl_copy_entry(acl_entry_t dest_d, acl_entry_t src_d);
-extern int	acl_create_entry(acl_t *acl_p, acl_entry_t *entry_p);
-extern int	acl_create_entry_np(acl_t *acl_p, acl_entry_t *entry_p, int entry_index);
-extern int	acl_delete_entry(acl_t acl, acl_entry_t entry_d);
-extern int	acl_get_entry(acl_t acl, int entry_id, acl_entry_t *entry_p);
-extern int	acl_valid(acl_t acl);
-extern int	acl_valid_fd_np(int fd, acl_type_t type, acl_t acl);
-extern int	acl_valid_file_np(const char *path, acl_type_t type, acl_t acl);
-extern int	acl_valid_link_np(const char *path, acl_type_t type, acl_t acl);
-
-/* 23.1.6.2 (2) Manipulate permissions within an ACL entry */
-extern int	acl_add_perm(acl_permset_t permset_d, acl_perm_t perm);
-extern int	acl_calc_mask(acl_t *acl_p);	/* not supported */
-extern int	acl_clear_perms(acl_permset_t permset_d);
-extern int	acl_delete_perm(acl_permset_t permset_d, acl_perm_t perm);
-extern int	acl_get_perm_np(acl_permset_t permset_d, acl_perm_t perm);
-extern int 	acl_get_permset(acl_entry_t entry_d, acl_permset_t *permset_p);
-extern int	acl_set_permset(acl_entry_t entry_d, acl_permset_t permset_d);
-
-/* nonstandard - manipulate permissions within an ACL entry using bitmasks */
-extern int	acl_maximal_permset_mask_np(acl_permset_mask_t * mask_p) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-extern int	acl_get_permset_mask_np(acl_entry_t entry_d, acl_permset_mask_t * mask_p) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-extern int	acl_set_permset_mask_np(acl_entry_t entry_d, acl_permset_mask_t mask) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-
-/* nonstandard - manipulate flags on ACLs and entries */
-extern int	acl_add_flag_np(acl_flagset_t flagset_d, acl_flag_t flag);
-extern int	acl_clear_flags_np(acl_flagset_t flagset_d);
-extern int	acl_delete_flag_np(acl_flagset_t flagset_d, acl_flag_t flag);
-extern int	acl_get_flag_np(acl_flagset_t flagset_d, acl_flag_t flag);
-extern int	acl_get_flagset_np(void *obj_p, acl_flagset_t *flagset_p);
-extern int	acl_set_flagset_np(void *obj_p, acl_flagset_t flagset_d);
-
-/* 23.1.6.2 (3) Manipulate ACL entry tag type and qualifier */
-extern void	*acl_get_qualifier(acl_entry_t entry_d);
-extern int	acl_get_tag_type(acl_entry_t entry_d, acl_tag_t *tag_type_p);
-extern int	acl_set_qualifier(acl_entry_t entry_d, const void *tag_qualifier_p);
-extern int	acl_set_tag_type(acl_entry_t entry_d, acl_tag_t tag_type);
-
-/* 23.1.6.3 ACL manipulation on an Object */
-extern int	acl_delete_def_file(const char *path_p); /* not supported */
-extern acl_t 	acl_get_fd(int fd);
-extern acl_t	acl_get_fd_np(int fd, acl_type_t type);
-extern acl_t	acl_get_file(const char *path_p, acl_type_t type);
-extern acl_t	acl_get_link_np(const char *path_p, acl_type_t type);
-extern int	acl_set_fd(int fd, acl_t acl);
-extern int	acl_set_fd_np(int fd, acl_t acl, acl_type_t acl_type);
-extern int	acl_set_file(const char *path_p, acl_type_t type, acl_t acl);
-extern int	acl_set_link_np(const char *path_p, acl_type_t type, acl_t acl);
-
-/* 23.1.6.4 ACL Format translation */
-extern ssize_t	acl_copy_ext(void *buf_p, acl_t acl, ssize_t size);
-extern ssize_t	acl_copy_ext_native(void *buf_p, acl_t acl, ssize_t size);
-extern acl_t	acl_copy_int(const void *buf_p);
-extern acl_t	acl_copy_int_native(const void *buf_p);
-extern acl_t	acl_from_text(const char *buf_p);
-extern ssize_t	acl_size(acl_t acl);
-extern char	*acl_to_text(acl_t acl, ssize_t *len_p);
-__END_DECLS
-
-#endif /* _SYS_ACL_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/attr.h b/lib/libc/include/x86_64-macos.10-none/sys/attr.h
deleted file mode 100644
index 7de047ec5b..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/attr.h
+++ /dev/null
@@ -1,579 +0,0 @@
-/*
- * Copyright (c) 2000-2018 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-/*
- * attr.h - attribute data structures and interfaces
- *
- * Copyright (c) 1998, Apple Computer, Inc.  All Rights Reserved.
- */
-
-#ifndef _SYS_ATTR_H_
-#define _SYS_ATTR_H_
-
-#include <sys/appleapiopts.h>
-
-#ifdef __APPLE_API_UNSTABLE
-#include <sys/types.h>
-#include <sys/ucred.h>
-#include <sys/time.h>
-#include <sys/cdefs.h>
-
-#define FSOPT_NOFOLLOW          0x00000001
-#define FSOPT_NOINMEMUPDATE     0x00000002
-#define FSOPT_REPORT_FULLSIZE   0x00000004
-/* The following option only valid when requesting ATTR_CMN_RETURNED_ATTRS */
-#define FSOPT_PACK_INVAL_ATTRS  0x00000008
-
-
-#define FSOPT_ATTR_CMN_EXTENDED 0x00000020
-
-/* we currently aren't anywhere near this amount for a valid
- * fssearchblock.sizeofsearchparams1 or fssearchblock.sizeofsearchparams2
- * but we put a sanity check in to avoid abuse of the value passed in from
- * user land.
- */
-#define SEARCHFS_MAX_SEARCHPARMS  4096
-
-typedef u_int32_t text_encoding_t;
-
-typedef u_int32_t fsobj_type_t;
-
-typedef u_int32_t fsobj_tag_t;
-
-typedef u_int32_t fsfile_type_t;
-
-typedef u_int32_t fsvolid_t;
-
-#include <sys/_types/_fsobj_id_t.h> /* file object id type */
-
-typedef u_int32_t attrgroup_t;
-
-struct attrlist {
-	u_short bitmapcount;                    /* number of attr. bit sets in list (should be 5) */
-	u_int16_t reserved;                     /* (to maintain 4-byte alignment) */
-	attrgroup_t commonattr;                 /* common attribute group */
-	attrgroup_t volattr;                    /* Volume attribute group */
-	attrgroup_t dirattr;                    /* directory attribute group */
-	attrgroup_t fileattr;                   /* file attribute group */
-	attrgroup_t forkattr;                   /* fork attribute group */
-};
-#define ATTR_BIT_MAP_COUNT 5
-
-typedef struct attribute_set {
-	attrgroup_t commonattr;                 /* common attribute group */
-	attrgroup_t volattr;                    /* Volume attribute group */
-	attrgroup_t dirattr;                    /* directory attribute group */
-	attrgroup_t fileattr;                   /* file attribute group */
-	attrgroup_t forkattr;                   /* fork attribute group */
-} attribute_set_t;
-
-typedef struct attrreference {
-	int32_t     attr_dataoffset;
-	u_int32_t   attr_length;
-} attrreference_t;
-
-/* XXX PPD This is derived from HFSVolumePriv.h and should perhaps be referenced from there? */
-
-struct diskextent {
-	u_int32_t                                       startblock;                             /* first block allocated */
-	u_int32_t                                       blockcount;                             /* number of blocks allocated */
-};
-
-typedef struct diskextent extentrecord[8];
-
-typedef u_int32_t vol_capabilities_set_t[4];
-
-#define VOL_CAPABILITIES_FORMAT 0
-#define VOL_CAPABILITIES_INTERFACES 1
-#define VOL_CAPABILITIES_RESERVED1 2
-#define VOL_CAPABILITIES_RESERVED2 3
-
-typedef struct vol_capabilities_attr {
-	vol_capabilities_set_t capabilities;
-	vol_capabilities_set_t valid;
-} vol_capabilities_attr_t;
-
-/*
- * XXX this value needs to be raised - 3893388
- */
-#define ATTR_MAX_BUFFER         8192
-
-/*
- * VOL_CAP_FMT_PERSISTENTOBJECTIDS: When set, the volume has object IDs
- * that are persistent (retain their values even when the volume is
- * unmounted and remounted), and a file or directory can be looked up
- * by ID.  Volumes that support VolFS and can support Carbon File ID
- * references should set this bit.
- *
- * VOL_CAP_FMT_SYMBOLICLINKS: When set, the volume supports symbolic
- * links.  The symlink(), readlink(), and lstat() calls all use this
- * symbolic link.
- *
- * VOL_CAP_FMT_HARDLINKS: When set, the volume supports hard links.
- * The link() call creates hard links.
- *
- * VOL_CAP_FMT_JOURNAL: When set, the volume is capable of supporting
- * a journal used to speed recovery in case of unplanned shutdown
- * (such as a power outage or crash).  This bit does not necessarily
- * mean the volume is actively using a journal for recovery.
- *
- * VOL_CAP_FMT_JOURNAL_ACTIVE: When set, the volume is currently using
- * a journal for use in speeding recovery after an unplanned shutdown.
- * This bit can be set only if VOL_CAP_FMT_JOURNAL is also set.
- *
- * VOL_CAP_FMT_NO_ROOT_TIMES: When set, the volume format does not
- * store reliable times for the root directory, so you should not
- * depend on them to detect changes, etc.
- *
- * VOL_CAP_FMT_SPARSE_FILES: When set, the volume supports sparse files.
- * That is, files which can have "holes" that have never been written
- * to, and are not allocated on disk.  Sparse files may have an
- * allocated size that is less than the file's logical length.
- *
- * VOL_CAP_FMT_ZERO_RUNS: For security reasons, parts of a file (runs)
- * that have never been written to must appear to contain zeroes.  When
- * this bit is set, the volume keeps track of allocated but unwritten
- * runs of a file so that it can substitute zeroes without actually
- * writing zeroes to the media.  This provides performance similar to
- * sparse files, but not the space savings.
- *
- * VOL_CAP_FMT_CASE_SENSITIVE: When set, file and directory names are
- * case sensitive (upper and lower case are different).  When clear,
- * an upper case character is equivalent to a lower case character,
- * and you can't have two names that differ solely in the case of
- * the characters.
- *
- * VOL_CAP_FMT_CASE_PRESERVING: When set, file and directory names
- * preserve the difference between upper and lower case.  If clear,
- * the volume may change the case of some characters (typically
- * making them all upper or all lower case).  A volume that sets
- * VOL_CAP_FMT_CASE_SENSITIVE should also set VOL_CAP_FMT_CASE_PRESERVING.
- *
- * VOL_CAP_FMT_FAST_STATFS: This bit is used as a hint to upper layers
- * (especially Carbon) that statfs() is fast enough that its results
- * need not be cached by those upper layers.  A volume that caches
- * the statfs information in its in-memory structures should set this bit.
- * A volume that must always read from disk or always perform a network
- * transaction should not set this bit.
- *
- * VOL_CAP_FMT_2TB_FILESIZE: If this bit is set the volume format supports
- * file sizes larger than 4GB, and potentially up to 2TB; it does not
- * indicate whether the filesystem supports files larger than that.
- *
- * VOL_CAP_FMT_OPENDENYMODES: When set, the volume supports open deny
- * modes (e.g. "open for read write, deny write"; effectively, mandatory
- * file locking based on open modes).
- *
- * VOL_CAP_FMT_HIDDEN_FILES: When set, the volume supports the UF_HIDDEN
- * file flag, and the UF_HIDDEN flag is mapped to that volume's native
- * "hidden" or "invisible" bit (which may be the invisible bit from the
- * Finder Info extended attribute).
- *
- * VOL_CAP_FMT_PATH_FROM_ID:  When set, the volume supports the ability
- * to derive a pathname to the root of the file system given only the
- * id of an object.  This also implies that object ids on this file
- * system are persistent and not recycled.  This is a very specialized
- * capability and it is assumed that most file systems will not support
- * it.  Its use is for legacy non-posix APIs like ResolveFileIDRef.
- *
- * VOL_CAP_FMT_NO_VOLUME_SIZES: When set, the volume does not support
- * returning values for total data blocks, available blocks, or free blocks
- * (as in f_blocks, f_bavail, or f_bfree in "struct statfs").  Historically,
- * those values were set to 0xFFFFFFFF for volumes that did not support them.
- *
- * VOL_CAP_FMT_DECMPFS_COMPRESSION: When set, the volume supports transparent
- * decompression of compressed files using decmpfs.
- *
- * VOL_CAP_FMT_64BIT_OBJECT_IDS: When set, the volume uses object IDs that
- * are 64-bit. This means that ATTR_CMN_FILEID and ATTR_CMN_PARENTID are the
- * only legitimate attributes for obtaining object IDs from this volume and the
- * 32-bit fid_objno fields of the fsobj_id_t returned by ATTR_CMN_OBJID,
- * ATTR_CMN_OBJPERMID, and ATTR_CMN_PAROBJID are undefined.
- *
- * VOL_CAP_FMT_DIR_HARDLINKS: When set, the volume supports directory
- * hard links.
- *
- * VOL_CAP_FMT_DOCUMENT_ID: When set, the volume supports document IDs
- * (an ID which persists across object ID changes) for document revisions.
- *
- * VOL_CAP_FMT_WRITE_GENERATION_COUNT: When set, the volume supports write
- * generation counts (a count of how many times an object has been modified)
- *
- * VOL_CAP_FMT_NO_IMMUTABLE_FILES: When set, the volume does not support
- * setting the UF_IMMUTABLE flag.
- *
- * VOL_CAP_FMT_NO_PERMISSIONS: When set, the volume does not support setting
- * permissions.
- *
- * VOL_CAP_FMT_SHARED_SPACE: When set, the volume supports sharing space with
- * other filesystems i.e. multiple logical filesystems can exist in the same
- * "partition". An implication of this is that the filesystem which sets
- * this capability treats waitfor arguments to VFS_SYNC as bit flags.
- *
- * VOL_CAP_FMT_VOL_GROUPS: When set, this volume is part of a volume-group
- * that implies multiple volumes must be mounted in order to boot and root the
- * operating system. Typically, this means a read-only system volume and a
- * writable data volume.
- */
-#define VOL_CAP_FMT_PERSISTENTOBJECTIDS         0x00000001
-#define VOL_CAP_FMT_SYMBOLICLINKS               0x00000002
-#define VOL_CAP_FMT_HARDLINKS                   0x00000004
-#define VOL_CAP_FMT_JOURNAL                     0x00000008
-#define VOL_CAP_FMT_JOURNAL_ACTIVE              0x00000010
-#define VOL_CAP_FMT_NO_ROOT_TIMES               0x00000020
-#define VOL_CAP_FMT_SPARSE_FILES                0x00000040
-#define VOL_CAP_FMT_ZERO_RUNS                   0x00000080
-#define VOL_CAP_FMT_CASE_SENSITIVE              0x00000100
-#define VOL_CAP_FMT_CASE_PRESERVING             0x00000200
-#define VOL_CAP_FMT_FAST_STATFS                 0x00000400
-#define VOL_CAP_FMT_2TB_FILESIZE                0x00000800
-#define VOL_CAP_FMT_OPENDENYMODES               0x00001000
-#define VOL_CAP_FMT_HIDDEN_FILES                0x00002000
-#define VOL_CAP_FMT_PATH_FROM_ID                0x00004000
-#define VOL_CAP_FMT_NO_VOLUME_SIZES             0x00008000
-#define VOL_CAP_FMT_DECMPFS_COMPRESSION         0x00010000
-#define VOL_CAP_FMT_64BIT_OBJECT_IDS            0x00020000
-#define VOL_CAP_FMT_DIR_HARDLINKS               0x00040000
-#define VOL_CAP_FMT_DOCUMENT_ID                 0x00080000
-#define VOL_CAP_FMT_WRITE_GENERATION_COUNT      0x00100000
-#define VOL_CAP_FMT_NO_IMMUTABLE_FILES          0x00200000
-#define VOL_CAP_FMT_NO_PERMISSIONS              0x00400000
-#define VOL_CAP_FMT_SHARED_SPACE                0x00800000
-#define VOL_CAP_FMT_VOL_GROUPS                  0x01000000
-
-/*
- * VOL_CAP_INT_SEARCHFS: When set, the volume implements the
- * searchfs() system call (the vnop_searchfs vnode operation).
- *
- * VOL_CAP_INT_ATTRLIST: When set, the volume implements the
- * getattrlist() and setattrlist() system calls (vnop_getattrlist
- * and vnop_setattrlist vnode operations) for the volume, files,
- * and directories.  The volume may or may not implement the
- * readdirattr() system call.  XXX Is there any minimum set
- * of attributes that should be supported?  To determine the
- * set of supported attributes, get the ATTR_VOL_ATTRIBUTES
- * attribute of the volume.
- *
- * VOL_CAP_INT_NFSEXPORT: When set, the volume implements exporting
- * of NFS volumes.
- *
- * VOL_CAP_INT_READDIRATTR: When set, the volume implements the
- * readdirattr() system call (vnop_readdirattr vnode operation).
- *
- * VOL_CAP_INT_EXCHANGEDATA: When set, the volume implements the
- * exchangedata() system call (VNOP_EXCHANGE vnode operation).
- *
- * VOL_CAP_INT_COPYFILE: When set, the volume implements the
- * VOP_COPYFILE vnode operation.  (XXX There should be a copyfile()
- * system call in <unistd.h>.)
- *
- * VOL_CAP_INT_ALLOCATE: When set, the volume implements the
- * VNOP_ALLOCATE vnode operation, which means it implements the
- * F_PREALLOCATE selector of fcntl(2).
- *
- * VOL_CAP_INT_VOL_RENAME: When set, the volume implements the
- * ATTR_VOL_NAME attribute for both getattrlist() and setattrlist().
- * The volume can be renamed by setting ATTR_VOL_NAME with setattrlist().
- *
- * VOL_CAP_INT_ADVLOCK: When set, the volume implements POSIX style
- * byte range locks via vnop_advlock (accessible from fcntl(2)).
- *
- * VOL_CAP_INT_FLOCK: When set, the volume implements whole-file flock(2)
- * style locks via vnop_advlock.  This includes the O_EXLOCK and O_SHLOCK
- * flags of the open(2) call.
- *
- * VOL_CAP_INT_EXTENDED_SECURITY: When set, the volume implements
- * extended security (ACLs).
- *
- * VOL_CAP_INT_USERACCESS:  When set, the volume supports the
- * ATTR_CMN_USERACCESS attribute (used to get the user's access
- * mode to the file).
- *
- * VOL_CAP_INT_MANLOCK: When set, the volume supports AFP-style
- * mandatory byte range locks via an ioctl().
- *
- * VOL_CAP_INT_EXTENDED_ATTR: When set, the volume implements
- * native extended attribues.
- *
- * VOL_CAP_INT_NAMEDSTREAMS: When set, the volume supports
- * native named streams.
- *
- * VOL_CAP_INT_CLONE: When set, the volume supports clones.
- *
- * VOL_CAP_INT_SNAPSHOT: When set, the volume supports snapshots.
- *
- * VOL_CAP_INT_RENAME_SWAP: When set, the volume supports swapping
- * file system objects.
- *
- * VOL_CAP_INT_RENAME_EXCL: When set, the volume supports an
- * exclusive rename operation.
- *
- * VOL_CAP_INT_RENAME_OPENFAIL: When set, the volume may fail rename
- * operations on files that are open.
- */
-#define VOL_CAP_INT_SEARCHFS                    0x00000001
-#define VOL_CAP_INT_ATTRLIST                    0x00000002
-#define VOL_CAP_INT_NFSEXPORT                   0x00000004
-#define VOL_CAP_INT_READDIRATTR                 0x00000008
-#define VOL_CAP_INT_EXCHANGEDATA                0x00000010
-#define VOL_CAP_INT_COPYFILE                    0x00000020
-#define VOL_CAP_INT_ALLOCATE                    0x00000040
-#define VOL_CAP_INT_VOL_RENAME                  0x00000080
-#define VOL_CAP_INT_ADVLOCK                     0x00000100
-#define VOL_CAP_INT_FLOCK                       0x00000200
-#define VOL_CAP_INT_EXTENDED_SECURITY           0x00000400
-#define VOL_CAP_INT_USERACCESS                  0x00000800
-#define VOL_CAP_INT_MANLOCK                     0x00001000
-#define VOL_CAP_INT_NAMEDSTREAMS                0x00002000
-#define VOL_CAP_INT_EXTENDED_ATTR               0x00004000
-#define VOL_CAP_INT_CLONE                       0x00010000
-#define VOL_CAP_INT_SNAPSHOT                    0x00020000
-#define VOL_CAP_INT_RENAME_SWAP                 0x00040000
-#define VOL_CAP_INT_RENAME_EXCL                 0x00080000
-#define VOL_CAP_INT_RENAME_OPENFAIL             0x00100000
-
-typedef struct vol_attributes_attr {
-	attribute_set_t validattr;
-	attribute_set_t nativeattr;
-} vol_attributes_attr_t;
-
-#define ATTR_CMN_NAME                           0x00000001
-#define ATTR_CMN_DEVID                          0x00000002
-#define ATTR_CMN_FSID                           0x00000004
-#define ATTR_CMN_OBJTYPE                        0x00000008
-#define ATTR_CMN_OBJTAG                         0x00000010
-#define ATTR_CMN_OBJID                          0x00000020
-#define ATTR_CMN_OBJPERMANENTID                 0x00000040
-#define ATTR_CMN_PAROBJID                       0x00000080
-#define ATTR_CMN_SCRIPT                         0x00000100
-#define ATTR_CMN_CRTIME                         0x00000200
-#define ATTR_CMN_MODTIME                        0x00000400
-#define ATTR_CMN_CHGTIME                        0x00000800
-#define ATTR_CMN_ACCTIME                        0x00001000
-#define ATTR_CMN_BKUPTIME                       0x00002000
-#define ATTR_CMN_FNDRINFO                       0x00004000
-#define ATTR_CMN_OWNERID                        0x00008000
-#define ATTR_CMN_GRPID                          0x00010000
-#define ATTR_CMN_ACCESSMASK                     0x00020000
-#define ATTR_CMN_FLAGS                          0x00040000
-
-/* The following were defined as:				*/
-/*      #define ATTR_CMN_NAMEDATTRCOUNT		0x00080000	*/
-/*      #define ATTR_CMN_NAMEDATTRLIST		0x00100000	*/
-/* These bits have been salvaged for use as:			*/
-/*	#define ATTR_CMN_GEN_COUNT		0x00080000	*/
-/*	#define ATTR_CMN_DOCUMENT_ID		0x00100000	*/
-/* They can only be used with the  FSOPT_ATTR_CMN_EXTENDED	*/
-/* option flag.                                                 */
-
-#define ATTR_CMN_GEN_COUNT                      0x00080000
-#define ATTR_CMN_DOCUMENT_ID                    0x00100000
-
-#define ATTR_CMN_USERACCESS                     0x00200000
-#define ATTR_CMN_EXTENDED_SECURITY              0x00400000
-#define ATTR_CMN_UUID                           0x00800000
-#define ATTR_CMN_GRPUUID                        0x01000000
-#define ATTR_CMN_FILEID                         0x02000000
-#define ATTR_CMN_PARENTID                       0x04000000
-#define ATTR_CMN_FULLPATH                       0x08000000
-#define ATTR_CMN_ADDEDTIME                      0x10000000
-#define ATTR_CMN_ERROR                          0x20000000
-#define ATTR_CMN_DATA_PROTECT_FLAGS             0x40000000
-
-/*
- * ATTR_CMN_RETURNED_ATTRS is only valid with getattrlist(2) and
- * getattrlistbulk(2). It is always the first attribute in the return buffer.
- */
-#define ATTR_CMN_RETURNED_ATTRS                 0x80000000
-
-#define ATTR_CMN_VALIDMASK                      0xFFFFFFFF
-/*
- * The settable ATTR_CMN_* attributes include the following:
- * ATTR_CMN_SCRIPT
- * ATTR_CMN_CRTIME
- * ATTR_CMN_MODTIME
- * ATTR_CMN_CHGTIME
- *
- * ATTR_CMN_ACCTIME
- * ATTR_CMN_BKUPTIME
- * ATTR_CMN_FNDRINFO
- * ATTR_CMN_OWNERID
- *
- * ATTR_CMN_GRPID
- * ATTR_CMN_ACCESSMASK
- * ATTR_CMN_FLAGS
- *
- * ATTR_CMN_EXTENDED_SECURITY
- * ATTR_CMN_UUID
- *
- * ATTR_CMN_GRPUUID
- *
- * ATTR_CMN_DATA_PROTECT_FLAGS
- */
-#define ATTR_CMN_SETMASK                        0x51C7FF00
-#define ATTR_CMN_VOLSETMASK                     0x00006700
-
-#define ATTR_VOL_FSTYPE                         0x00000001
-#define ATTR_VOL_SIGNATURE                      0x00000002
-#define ATTR_VOL_SIZE                           0x00000004
-#define ATTR_VOL_SPACEFREE                      0x00000008
-#define ATTR_VOL_SPACEAVAIL                     0x00000010
-#define ATTR_VOL_MINALLOCATION                  0x00000020
-#define ATTR_VOL_ALLOCATIONCLUMP                0x00000040
-#define ATTR_VOL_IOBLOCKSIZE                    0x00000080
-#define ATTR_VOL_OBJCOUNT                       0x00000100
-#define ATTR_VOL_FILECOUNT                      0x00000200
-#define ATTR_VOL_DIRCOUNT                       0x00000400
-#define ATTR_VOL_MAXOBJCOUNT                    0x00000800
-#define ATTR_VOL_MOUNTPOINT                     0x00001000
-#define ATTR_VOL_NAME                           0x00002000
-#define ATTR_VOL_MOUNTFLAGS                     0x00004000
-#define ATTR_VOL_MOUNTEDDEVICE                  0x00008000
-#define ATTR_VOL_ENCODINGSUSED                  0x00010000
-#define ATTR_VOL_CAPABILITIES                   0x00020000
-#define ATTR_VOL_UUID                           0x00040000
-#define ATTR_VOL_QUOTA_SIZE                     0x10000000
-#define ATTR_VOL_RESERVED_SIZE          0x20000000
-#define ATTR_VOL_ATTRIBUTES                     0x40000000
-#define ATTR_VOL_INFO                           0x80000000
-
-#define ATTR_VOL_VALIDMASK                      0xF007FFFF
-
-/*
- * The list of settable ATTR_VOL_* attributes include the following:
- * ATTR_VOL_NAME
- * ATTR_VOL_INFO
- */
-#define ATTR_VOL_SETMASK                        0x80002000
-
-
-/* File/directory attributes: */
-#define ATTR_DIR_LINKCOUNT                      0x00000001
-#define ATTR_DIR_ENTRYCOUNT                     0x00000002
-#define ATTR_DIR_MOUNTSTATUS                    0x00000004
-#define ATTR_DIR_ALLOCSIZE                      0x00000008
-#define ATTR_DIR_IOBLOCKSIZE                    0x00000010
-#define ATTR_DIR_DATALENGTH                     0x00000020
-
-/* ATTR_DIR_MOUNTSTATUS Flags: */
-#define   DIR_MNTSTATUS_MNTPOINT                0x00000001
-#define   DIR_MNTSTATUS_TRIGGER                 0x00000002
-
-#define ATTR_DIR_VALIDMASK                      0x0000003f
-#define ATTR_DIR_SETMASK                        0x00000000
-
-#define ATTR_FILE_LINKCOUNT                     0x00000001
-#define ATTR_FILE_TOTALSIZE                     0x00000002
-#define ATTR_FILE_ALLOCSIZE                     0x00000004
-#define ATTR_FILE_IOBLOCKSIZE                   0x00000008
-#define ATTR_FILE_DEVTYPE                       0x00000020
-#define ATTR_FILE_FORKCOUNT                     0x00000080
-#define ATTR_FILE_FORKLIST                      0x00000100
-#define ATTR_FILE_DATALENGTH                    0x00000200
-#define ATTR_FILE_DATAALLOCSIZE                 0x00000400
-#define ATTR_FILE_RSRCLENGTH                    0x00001000
-#define ATTR_FILE_RSRCALLOCSIZE                 0x00002000
-
-#define ATTR_FILE_VALIDMASK                     0x000037FF
-/*
- * Settable ATTR_FILE_* attributes include:
- * ATTR_FILE_DEVTYPE
- */
-#define ATTR_FILE_SETMASK                       0x00000020
-
-/* CMNEXT attributes extend the common attributes, but in the forkattr field */
-#define ATTR_CMNEXT_RELPATH     0x00000004
-#define ATTR_CMNEXT_PRIVATESIZE 0x00000008
-#define ATTR_CMNEXT_LINKID      0x00000010
-#define ATTR_CMNEXT_NOFIRMLINKPATH     0x00000020
-#define ATTR_CMNEXT_REALDEVID   0x00000040
-#define ATTR_CMNEXT_REALFSID    0x00000080
-#define ATTR_CMNEXT_CLONEID     0x00000100
-#define ATTR_CMNEXT_EXT_FLAGS   0x00000200
-
-#define ATTR_CMNEXT_VALIDMASK   0x000003fc
-#define ATTR_CMNEXT_SETMASK             0x00000000
-
-/* Deprecated fork attributes */
-#define ATTR_FORK_TOTALSIZE                     0x00000001
-#define ATTR_FORK_ALLOCSIZE                     0x00000002
-#define ATTR_FORK_RESERVED                      0xffffffff
-
-#define ATTR_FORK_VALIDMASK                     0x00000003
-#define ATTR_FORK_SETMASK                       0x00000000
-
-/* Obsolete, implemented, not supported */
-#define ATTR_CMN_NAMEDATTRCOUNT                 0x00080000
-#define ATTR_CMN_NAMEDATTRLIST                  0x00100000
-#define ATTR_FILE_CLUMPSIZE                     0x00000010      /* obsolete */
-#define ATTR_FILE_FILETYPE                      0x00000040      /* always zero */
-#define ATTR_FILE_DATAEXTENTS                   0x00000800      /* obsolete, HFS-specific */
-#define ATTR_FILE_RSRCEXTENTS                   0x00004000      /* obsolete, HFS-specific */
-
-/* Required attributes for getattrlistbulk(2) */
-#define ATTR_BULK_REQUIRED (ATTR_CMN_NAME | ATTR_CMN_RETURNED_ATTRS)
-
-/*
- * Searchfs
- */
-#define SRCHFS_START                            0x00000001
-#define SRCHFS_MATCHPARTIALNAMES                0x00000002
-#define SRCHFS_MATCHDIRS                        0x00000004
-#define SRCHFS_MATCHFILES                       0x00000008
-#define SRCHFS_SKIPLINKS                        0x00000010
-#define SRCHFS_SKIPINVISIBLE                    0x00000020
-#define SRCHFS_SKIPPACKAGES                     0x00000040
-#define SRCHFS_SKIPINAPPROPRIATE                0x00000080
-
-#define SRCHFS_NEGATEPARAMS                     0x80000000
-#define SRCHFS_VALIDOPTIONSMASK                 0x800000FF
-
-struct fssearchblock {
-	struct attrlist         *returnattrs;
-	void                            *returnbuffer;
-	size_t                          returnbuffersize;
-	u_long                          maxmatches;
-	struct timeval          timelimit;
-	void                            *searchparams1;
-	size_t                          sizeofsearchparams1;
-	void                            *searchparams2;
-	size_t                          sizeofsearchparams2;
-	struct attrlist         searchattrs;
-};
-
-
-struct searchstate {
-	uint32_t                        ss_union_flags;         // for SRCHFS_START
-	uint32_t                        ss_union_layer;         // 0 = top
-	u_char                          ss_fsstate[548];        // fs private
-} __attribute__((packed));
-
-#define FST_EOF (-1)                            /* end-of-file offset */
-
-#endif /* __APPLE_API_UNSTABLE */
-#endif /* !_SYS_ATTR_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/ioccom.h b/lib/libc/include/x86_64-macos.10-none/sys/ioccom.h
deleted file mode 100644
index 39c6964568..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/ioccom.h
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
-/*-
- * Copyright (c) 1982, 1986, 1990, 1993, 1994
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)ioccom.h	8.2 (Berkeley) 3/28/94
- */
-
-#ifndef _SYS_IOCCOM_H_
-#define _SYS_IOCCOM_H_
-
-#include <sys/_types.h>
-
-/*
- * Ioctl's have the command encoded in the lower word, and the size of
- * any in or out parameters in the upper word.  The high 3 bits of the
- * upper word are used to encode the in/out status of the parameter.
- */
-#define IOCPARM_MASK    0x1fff          /* parameter length, at most 13 bits */
-#define IOCPARM_LEN(x)  (((x) >> 16) & IOCPARM_MASK)
-#define IOCBASECMD(x)   ((x) & ~(IOCPARM_MASK << 16))
-#define IOCGROUP(x)     (((x) >> 8) & 0xff)
-
-#define IOCPARM_MAX     (IOCPARM_MASK + 1)      /* max size of ioctl args */
-/* no parameters */
-#define IOC_VOID        (__uint32_t)0x20000000
-/* copy parameters out */
-#define IOC_OUT         (__uint32_t)0x40000000
-/* copy parameters in */
-#define IOC_IN          (__uint32_t)0x80000000
-/* copy paramters in and out */
-#define IOC_INOUT       (IOC_IN|IOC_OUT)
-/* mask for IN/OUT/VOID */
-#define IOC_DIRMASK     (__uint32_t)0xe0000000
-
-#define _IOC(inout, group, num, len) \
-	(inout | ((len & IOCPARM_MASK) << 16) | ((group) << 8) | (num))
-#define _IO(g, n)        _IOC(IOC_VOID,	(g), (n), 0)
-#define _IOR(g, n, t)     _IOC(IOC_OUT,	(g), (n), sizeof(t))
-#define _IOW(g, n, t)     _IOC(IOC_IN,	(g), (n), sizeof(t))
-/* this should be _IORW, but stdio got there first */
-#define _IOWR(g, n, t)    _IOC(IOC_INOUT,	(g), (n), sizeof(t))
-
-#endif /* !_SYS_IOCCOM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/kauth.h b/lib/libc/include/x86_64-macos.10-none/sys/kauth.h
deleted file mode 100644
index 99784e35c8..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/kauth.h
+++ /dev/null
@@ -1,407 +0,0 @@
-/*
- * Copyright (c) 2004-2010 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
- * support for mandatory and extensible security protections.  This notice
- * is included in support of clause 2.2 (b) of the Apple Public License,
- * Version 2.0.
- */
-
-#ifndef _SYS_KAUTH_H
-#define _SYS_KAUTH_H
-
-#include <sys/appleapiopts.h>
-#include <sys/cdefs.h>
-#include <mach/boolean.h>
-#include <sys/_types.h>         /* __offsetof() */
-#include <sys/syslimits.h>      /* NGROUPS_MAX */
-
-#ifdef __APPLE_API_EVOLVING
-
-/*
- * Identities.
- */
-
-#define KAUTH_UID_NONE  (~(uid_t)0 - 100)       /* not a valid UID */
-#define KAUTH_GID_NONE  (~(gid_t)0 - 100)       /* not a valid GID */
-
-#include <sys/_types/_guid_t.h>
-
-/* NT Security Identifier, structure as defined by Microsoft */
-#pragma pack(1)    /* push packing of 1 byte */
-typedef struct {
-	u_int8_t                sid_kind;
-	u_int8_t                sid_authcount;
-	u_int8_t                sid_authority[6];
-#define KAUTH_NTSID_MAX_AUTHORITIES 16
-	u_int32_t       sid_authorities[KAUTH_NTSID_MAX_AUTHORITIES];
-} ntsid_t;
-#pragma pack()    /* pop packing to previous packing level */
-#define _NTSID_T
-
-/* valid byte count inside a SID structure */
-#define KAUTH_NTSID_HDRSIZE     (8)
-#define KAUTH_NTSID_SIZE(_s)    (KAUTH_NTSID_HDRSIZE + ((_s)->sid_authcount * sizeof(u_int32_t)))
-
-/*
- * External lookup message payload; this structure is shared between the
- * kernel group membership resolver, and the user space group membership
- * resolver daemon, and is use to communicate resolution requests from the
- * kernel to user space, and the result of that request from user space to
- * the kernel.
- */
-struct kauth_identity_extlookup {
-	u_int32_t       el_seqno;       /* request sequence number */
-	u_int32_t       el_result;      /* lookup result */
-#define KAUTH_EXTLOOKUP_SUCCESS         0       /* results here are good */
-#define KAUTH_EXTLOOKUP_BADRQ           1       /* request badly formatted */
-#define KAUTH_EXTLOOKUP_FAILURE         2       /* transient failure during lookup */
-#define KAUTH_EXTLOOKUP_FATAL           3       /* permanent failure during lookup */
-#define KAUTH_EXTLOOKUP_INPROG          100     /* request in progress */
-	u_int32_t       el_flags;
-#define KAUTH_EXTLOOKUP_VALID_UID       (1<<0)
-#define KAUTH_EXTLOOKUP_VALID_UGUID     (1<<1)
-#define KAUTH_EXTLOOKUP_VALID_USID      (1<<2)
-#define KAUTH_EXTLOOKUP_VALID_GID       (1<<3)
-#define KAUTH_EXTLOOKUP_VALID_GGUID     (1<<4)
-#define KAUTH_EXTLOOKUP_VALID_GSID      (1<<5)
-#define KAUTH_EXTLOOKUP_WANT_UID        (1<<6)
-#define KAUTH_EXTLOOKUP_WANT_UGUID      (1<<7)
-#define KAUTH_EXTLOOKUP_WANT_USID       (1<<8)
-#define KAUTH_EXTLOOKUP_WANT_GID        (1<<9)
-#define KAUTH_EXTLOOKUP_WANT_GGUID      (1<<10)
-#define KAUTH_EXTLOOKUP_WANT_GSID       (1<<11)
-#define KAUTH_EXTLOOKUP_WANT_MEMBERSHIP (1<<12)
-#define KAUTH_EXTLOOKUP_VALID_MEMBERSHIP (1<<13)
-#define KAUTH_EXTLOOKUP_ISMEMBER        (1<<14)
-#define KAUTH_EXTLOOKUP_VALID_PWNAM     (1<<15)
-#define KAUTH_EXTLOOKUP_WANT_PWNAM      (1<<16)
-#define KAUTH_EXTLOOKUP_VALID_GRNAM     (1<<17)
-#define KAUTH_EXTLOOKUP_WANT_GRNAM      (1<<18)
-#define KAUTH_EXTLOOKUP_VALID_SUPGRPS   (1<<19)
-#define KAUTH_EXTLOOKUP_WANT_SUPGRPS    (1<<20)
-
-	__darwin_pid_t  el_info_pid;            /* request on behalf of PID */
-	u_int64_t       el_extend;              /* extension field */
-	u_int32_t       el_info_reserved_1;     /* reserved (APPLE) */
-
-	uid_t           el_uid;         /* user ID */
-	guid_t          el_uguid;       /* user GUID */
-	u_int32_t       el_uguid_valid; /* TTL on translation result (seconds) */
-	ntsid_t         el_usid;        /* user NT SID */
-	u_int32_t       el_usid_valid;  /* TTL on translation result (seconds) */
-	gid_t           el_gid;         /* group ID */
-	guid_t          el_gguid;       /* group GUID */
-	u_int32_t       el_gguid_valid; /* TTL on translation result (seconds) */
-	ntsid_t         el_gsid;        /* group SID */
-	u_int32_t       el_gsid_valid;  /* TTL on translation result (seconds) */
-	u_int32_t       el_member_valid; /* TTL on group lookup result */
-	u_int32_t       el_sup_grp_cnt;  /* count of supplemental groups up to NGROUPS */
-	gid_t           el_sup_groups[NGROUPS_MAX];     /* supplemental group list */
-};
-
-struct kauth_cache_sizes {
-	u_int32_t kcs_group_size;
-	u_int32_t kcs_id_size;
-};
-
-#define KAUTH_EXTLOOKUP_REGISTER        (0)
-#define KAUTH_EXTLOOKUP_RESULT          (1<<0)
-#define KAUTH_EXTLOOKUP_WORKER          (1<<1)
-#define KAUTH_EXTLOOKUP_DEREGISTER      (1<<2)
-#define KAUTH_GET_CACHE_SIZES           (1<<3)
-#define KAUTH_SET_CACHE_SIZES           (1<<4)
-#define KAUTH_CLEAR_CACHES              (1<<5)
-
-#define IDENTITYSVC_ENTITLEMENT         "com.apple.private.identitysvc"
-
-
-
-/*
- * Generic Access Control Lists.
- */
-#if defined(KERNEL) || defined (_SYS_ACL_H)
-
-typedef u_int32_t kauth_ace_rights_t;
-
-/* Access Control List Entry (ACE) */
-struct kauth_ace {
-	guid_t          ace_applicable;
-	u_int32_t       ace_flags;
-#define KAUTH_ACE_KINDMASK              0xf
-#define KAUTH_ACE_PERMIT                1
-#define KAUTH_ACE_DENY                  2
-#define KAUTH_ACE_AUDIT                 3       /* not implemented */
-#define KAUTH_ACE_ALARM                 4       /* not implemented */
-#define KAUTH_ACE_INHERITED             (1<<4)
-#define KAUTH_ACE_FILE_INHERIT          (1<<5)
-#define KAUTH_ACE_DIRECTORY_INHERIT     (1<<6)
-#define KAUTH_ACE_LIMIT_INHERIT         (1<<7)
-#define KAUTH_ACE_ONLY_INHERIT          (1<<8)
-#define KAUTH_ACE_SUCCESS               (1<<9)  /* not implemented (AUDIT/ALARM) */
-#define KAUTH_ACE_FAILURE               (1<<10) /* not implemented (AUDIT/ALARM) */
-/* All flag bits controlling ACE inheritance */
-#define KAUTH_ACE_INHERIT_CONTROL_FLAGS         \
-	        (KAUTH_ACE_FILE_INHERIT |       \
-	         KAUTH_ACE_DIRECTORY_INHERIT |  \
-	         KAUTH_ACE_LIMIT_INHERIT |      \
-	         KAUTH_ACE_ONLY_INHERIT)
-	kauth_ace_rights_t ace_rights;          /* scope specific */
-	/* These rights are never tested, but may be present in an ACL */
-#define KAUTH_ACE_GENERIC_ALL           (1<<21)
-#define KAUTH_ACE_GENERIC_EXECUTE       (1<<22)
-#define KAUTH_ACE_GENERIC_WRITE         (1<<23)
-#define KAUTH_ACE_GENERIC_READ          (1<<24)
-};
-
-#ifndef _KAUTH_ACE
-#define _KAUTH_ACE
-typedef struct kauth_ace *kauth_ace_t;
-#endif
-
-
-/* Access Control List */
-struct kauth_acl {
-	u_int32_t       acl_entrycount;
-	u_int32_t       acl_flags;
-
-	struct kauth_ace acl_ace[1];
-};
-
-/*
- * XXX this value needs to be raised - 3893388
- */
-#define KAUTH_ACL_MAX_ENTRIES           128
-
-/*
- * The low 16 bits of the flags field are reserved for filesystem
- * internal use and must be preserved by all APIs.  This includes
- * round-tripping flags through user-space interfaces.
- */
-#define KAUTH_ACL_FLAGS_PRIVATE (0xffff)
-
-/*
- * The high 16 bits of the flags are used to store attributes and
- * to request specific handling of the ACL.
- */
-
-/* inheritance will be deferred until the first rename operation */
-#define KAUTH_ACL_DEFER_INHERIT (1<<16)
-/* this ACL must not be overwritten as part of an inheritance operation */
-#define KAUTH_ACL_NO_INHERIT    (1<<17)
-
-/* acl_entrycount that tells us the ACL is not valid */
-#define KAUTH_FILESEC_NOACL ((u_int32_t)(-1))
-
-/*
- * If the acl_entrycount field is KAUTH_FILESEC_NOACL, then the size is the
- * same as a kauth_acl structure; the intent is to put an actual entrycount of
- * KAUTH_FILESEC_NOACL on disk to distinguish a kauth_filesec_t with an empty
- * entry (Windows treats this as "deny all") from one that merely indicates a
- * file group and/or owner guid values.
- */
-#define KAUTH_ACL_SIZE(c)       (__offsetof(struct kauth_acl, acl_ace) + ((u_int32_t)(c) != KAUTH_FILESEC_NOACL ? ((c) * sizeof(struct kauth_ace)) : 0))
-#define KAUTH_ACL_COPYSIZE(p)   KAUTH_ACL_SIZE((p)->acl_entrycount)
-
-
-#ifndef _KAUTH_ACL
-#define _KAUTH_ACL
-typedef struct kauth_acl *kauth_acl_t;
-#endif
-
-
-
-/*
- * Extended File Security.
- */
-
-/* File Security information */
-struct kauth_filesec {
-	u_int32_t       fsec_magic;
-#define KAUTH_FILESEC_MAGIC     0x012cc16d
-	guid_t          fsec_owner;
-	guid_t          fsec_group;
-
-	struct kauth_acl fsec_acl;
-};
-
-/* backwards compatibility */
-#define fsec_entrycount fsec_acl.acl_entrycount
-#define fsec_flags      fsec_acl.acl_flags
-#define fsec_ace        fsec_acl.acl_ace
-#define KAUTH_FILESEC_FLAGS_PRIVATE     KAUTH_ACL_FLAGS_PRIVATE
-#define KAUTH_FILESEC_DEFER_INHERIT     KAUTH_ACL_DEFER_INHERIT
-#define KAUTH_FILESEC_NO_INHERIT        KAUTH_ACL_NO_INHERIT
-#define KAUTH_FILESEC_NONE      ((kauth_filesec_t)0)
-#define KAUTH_FILESEC_WANTED    ((kauth_filesec_t)1)
-
-#ifndef _KAUTH_FILESEC
-#define _KAUTH_FILESEC
-typedef struct kauth_filesec *kauth_filesec_t;
-#endif
-
-#define KAUTH_FILESEC_SIZE(c)           (__offsetof(struct kauth_filesec, fsec_acl) + __offsetof(struct kauth_acl, acl_ace) + (c) * sizeof(struct kauth_ace))
-#define KAUTH_FILESEC_COPYSIZE(p)       KAUTH_FILESEC_SIZE(((p)->fsec_entrycount == KAUTH_FILESEC_NOACL) ? 0 : (p)->fsec_entrycount)
-#define KAUTH_FILESEC_COUNT(s)          (((s)  - KAUTH_FILESEC_SIZE(0)) / sizeof(struct kauth_ace))
-#define KAUTH_FILESEC_VALID(s)          ((s) >= KAUTH_FILESEC_SIZE(0) && (((s) - KAUTH_FILESEC_SIZE(0)) % sizeof(struct kauth_ace)) == 0)
-
-#define KAUTH_FILESEC_XATTR     "com.apple.system.Security"
-
-/* Allowable first arguments to kauth_filesec_acl_setendian() */
-#define KAUTH_ENDIAN_HOST       0x00000001      /* set host endianness */
-#define KAUTH_ENDIAN_DISK       0x00000002      /* set disk endianness */
-
-#endif /* KERNEL || <sys/acl.h> */
-
-
-
-/* Actions, also rights bits in an ACE */
-
-#if defined(KERNEL) || defined (_SYS_ACL_H)
-#define KAUTH_VNODE_READ_DATA                   (1U<<1)
-#define KAUTH_VNODE_LIST_DIRECTORY              KAUTH_VNODE_READ_DATA
-#define KAUTH_VNODE_WRITE_DATA                  (1U<<2)
-#define KAUTH_VNODE_ADD_FILE                    KAUTH_VNODE_WRITE_DATA
-#define KAUTH_VNODE_EXECUTE                     (1U<<3)
-#define KAUTH_VNODE_SEARCH                      KAUTH_VNODE_EXECUTE
-#define KAUTH_VNODE_DELETE                      (1U<<4)
-#define KAUTH_VNODE_APPEND_DATA                 (1U<<5)
-#define KAUTH_VNODE_ADD_SUBDIRECTORY            KAUTH_VNODE_APPEND_DATA
-#define KAUTH_VNODE_DELETE_CHILD                (1U<<6)
-#define KAUTH_VNODE_READ_ATTRIBUTES             (1U<<7)
-#define KAUTH_VNODE_WRITE_ATTRIBUTES            (1U<<8)
-#define KAUTH_VNODE_READ_EXTATTRIBUTES          (1U<<9)
-#define KAUTH_VNODE_WRITE_EXTATTRIBUTES         (1U<<10)
-#define KAUTH_VNODE_READ_SECURITY               (1U<<11)
-#define KAUTH_VNODE_WRITE_SECURITY              (1U<<12)
-#define KAUTH_VNODE_TAKE_OWNERSHIP              (1U<<13)
-
-/* backwards compatibility only */
-#define KAUTH_VNODE_CHANGE_OWNER                KAUTH_VNODE_TAKE_OWNERSHIP
-
-/* For Windows interoperability only */
-#define KAUTH_VNODE_SYNCHRONIZE                 (1U<<20)
-
-/* (1<<21) - (1<<24) are reserved for generic rights bits */
-
-/* Actions not expressed as rights bits */
-/*
- * Authorizes the vnode as the target of a hard link.
- */
-#define KAUTH_VNODE_LINKTARGET                  (1U<<25)
-
-/*
- * Indicates that other steps have been taken to authorise the action,
- * but authorisation should be denied for immutable objects.
- */
-#define KAUTH_VNODE_CHECKIMMUTABLE              (1U<<26)
-
-/* Action modifiers */
-/*
- * The KAUTH_VNODE_ACCESS bit is passed to the callback if the authorisation
- * request in progress is advisory, rather than authoritative.  Listeners
- * performing consequential work (i.e. not strictly checking authorisation)
- * may test this flag to avoid performing unnecessary work.
- *
- * This bit will never be present in an ACE.
- */
-#define KAUTH_VNODE_ACCESS                      (1U<<31)
-
-/*
- * The KAUTH_VNODE_NOIMMUTABLE bit is passed to the callback along with the
- * KAUTH_VNODE_WRITE_SECURITY bit (and no others) to indicate that the
- * caller wishes to change one or more of the immutable flags, and the
- * state of these flags should not be considered when authorizing the request.
- * The system immutable flags are only ignored when the system securelevel
- * is low enough to allow their removal.
- */
-#define KAUTH_VNODE_NOIMMUTABLE                 (1U<<30)
-
-
-/*
- * fake right that is composed by the following...
- * vnode must have search for owner, group and world allowed
- * plus there must be no deny modes present for SEARCH... this fake
- * right is used by the fast lookup path to avoid checking
- * for an exact match on the last credential to lookup
- * the component being acted on
- */
-#define KAUTH_VNODE_SEARCHBYANYONE              (1U<<29)
-
-
-/*
- * when passed as an 'action' to "vnode_uncache_authorized_actions"
- * it indicates that all of the cached authorizations for that
- * vnode should be invalidated
- */
-#define KAUTH_INVALIDATE_CACHED_RIGHTS          ((kauth_action_t)~0)
-
-
-
-/* The expansions of the GENERIC bits at evaluation time */
-#define KAUTH_VNODE_GENERIC_READ_BITS   (KAUTH_VNODE_READ_DATA |                \
-	                                KAUTH_VNODE_READ_ATTRIBUTES |           \
-	                                KAUTH_VNODE_READ_EXTATTRIBUTES |        \
-	                                KAUTH_VNODE_READ_SECURITY)
-
-#define KAUTH_VNODE_GENERIC_WRITE_BITS  (KAUTH_VNODE_WRITE_DATA |               \
-	                                KAUTH_VNODE_APPEND_DATA |               \
-	                                KAUTH_VNODE_DELETE |                    \
-	                                KAUTH_VNODE_DELETE_CHILD |              \
-	                                KAUTH_VNODE_WRITE_ATTRIBUTES |          \
-	                                KAUTH_VNODE_WRITE_EXTATTRIBUTES |       \
-	                                KAUTH_VNODE_WRITE_SECURITY)
-
-#define KAUTH_VNODE_GENERIC_EXECUTE_BITS (KAUTH_VNODE_EXECUTE)
-
-#define KAUTH_VNODE_GENERIC_ALL_BITS    (KAUTH_VNODE_GENERIC_READ_BITS |        \
-	                                KAUTH_VNODE_GENERIC_WRITE_BITS |        \
-	                                KAUTH_VNODE_GENERIC_EXECUTE_BITS)
-
-/*
- * Some sets of bits, defined here for convenience.
- */
-#define KAUTH_VNODE_WRITE_RIGHTS        (KAUTH_VNODE_ADD_FILE |                         \
-	                                KAUTH_VNODE_ADD_SUBDIRECTORY |                  \
-	                                KAUTH_VNODE_DELETE_CHILD |                      \
-	                                KAUTH_VNODE_WRITE_DATA |                        \
-	                                KAUTH_VNODE_APPEND_DATA |                       \
-	                                KAUTH_VNODE_DELETE |                            \
-	                                KAUTH_VNODE_WRITE_ATTRIBUTES |                  \
-	                                KAUTH_VNODE_WRITE_EXTATTRIBUTES |               \
-	                                KAUTH_VNODE_WRITE_SECURITY |                    \
-	                                KAUTH_VNODE_TAKE_OWNERSHIP |                    \
-	                                KAUTH_VNODE_LINKTARGET |                        \
-	                                KAUTH_VNODE_CHECKIMMUTABLE)
-
-
-#endif /* KERNEL || <sys/acl.h> */
-
-
-#endif /* __APPLE_API_EVOLVING */
-#endif /* _SYS_KAUTH_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/mman.h b/lib/libc/include/x86_64-macos.10-none/sys/mman.h
deleted file mode 100644
index fec1caac71..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/mman.h
+++ /dev/null
@@ -1,250 +0,0 @@
-/*
- * Copyright (c) 2000-2019 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
-/*-
- * Copyright (c) 1982, 1986, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)mman.h	8.1 (Berkeley) 6/2/93
- */
-
-/*
- * Currently unsupported:
- *
- * [TYM]	POSIX_TYPED_MEM_ALLOCATE
- * [TYM]	POSIX_TYPED_MEM_ALLOCATE_CONTIG
- * [TYM]	POSIX_TYPED_MEM_MAP_ALLOCATABLE
- * [TYM]	struct posix_typed_mem_info
- * [TYM]	posix_mem_offset()
- * [TYM]	posix_typed_mem_get_info()
- * [TYM]	posix_typed_mem_open()
- */
-
-#ifndef _SYS_MMAN_H_
-#define _SYS_MMAN_H_
-
-#include <sys/appleapiopts.h>
-#include <sys/cdefs.h>
-
-#include <sys/_types.h>
-
-/*
- * [various] The mode_t, off_t, and size_t types shall be defined as
- * described in <sys/types.h>
- */
-#include <sys/_types/_mode_t.h>
-#include <sys/_types/_off_t.h>
-#include <sys/_types/_size_t.h>
-
-/*
- * Protections are chosen from these bits, or-ed together
- */
-#define PROT_NONE       0x00    /* [MC2] no permissions */
-#define PROT_READ       0x01    /* [MC2] pages can be read */
-#define PROT_WRITE      0x02    /* [MC2] pages can be written */
-#define PROT_EXEC       0x04    /* [MC2] pages can be executed */
-
-/*
- * Flags contain sharing type and options.
- * Sharing types; choose one.
- */
-#define MAP_SHARED      0x0001          /* [MF|SHM] share changes */
-#define MAP_PRIVATE     0x0002          /* [MF|SHM] changes are private */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define MAP_COPY        MAP_PRIVATE     /* Obsolete */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/*
- * Other flags
- */
-#define MAP_FIXED        0x0010 /* [MF|SHM] interpret addr exactly */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define MAP_RENAME       0x0020 /* Sun: rename private pages to file */
-#define MAP_NORESERVE    0x0040 /* Sun: don't reserve needed swap area */
-#define MAP_RESERVED0080 0x0080 /* previously unimplemented MAP_INHERIT */
-#define MAP_NOEXTEND     0x0100 /* for MAP_FILE, don't change file size */
-#define MAP_HASSEMAPHORE 0x0200 /* region may contain semaphores */
-#define MAP_NOCACHE      0x0400 /* don't cache pages for this mapping */
-#define MAP_JIT          0x0800 /* Allocate a region that will be used for JIT purposes */
-
-/*
- * Mapping type
- */
-#define MAP_FILE        0x0000  /* map from file (default) */
-#define MAP_ANON        0x1000  /* allocated from memory, swap space */
-#define MAP_ANONYMOUS   MAP_ANON
-
-/*
- * The MAP_RESILIENT_* flags can be used when the caller wants to map some
- * possibly unreliable memory and be able to access it safely, possibly
- * getting the wrong contents rather than raising any exception.
- * For safety reasons, such mappings have to be read-only (PROT_READ access
- * only).
- *
- * MAP_RESILIENT_CODESIGN:
- *      accessing this mapping will not generate code-signing violations,
- *	even if the contents are tainted.
- * MAP_RESILIENT_MEDIA:
- *	accessing this mapping will not generate an exception if the contents
- *	are not available (unreachable removable or remote media, access beyond
- *	end-of-file, ...).  Missing contents will be replaced with zeroes.
- */
-#define MAP_RESILIENT_CODESIGN  0x2000 /* no code-signing failures */
-#define MAP_RESILIENT_MEDIA     0x4000 /* no backing-store failures */
-
-#if !defined(CONFIG_EMBEDDED)
-#define MAP_32BIT       0x8000          /* Return virtual addresses <4G only: Requires entitlement */
-#endif  /* !defined(CONFIG_EMBEDDED) */
-
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-/*
- * Process memory locking
- */
-#define MCL_CURRENT     0x0001  /* [ML] Lock only current memory */
-#define MCL_FUTURE      0x0002  /* [ML] Lock all future memory as well */
-
-/*
- * Error return from mmap()
- */
-#define MAP_FAILED      ((void *)-1)    /* [MF|SHM] mmap failed */
-
-/*
- * msync() flags
- */
-#define MS_ASYNC        0x0001  /* [MF|SIO] return immediately */
-#define MS_INVALIDATE   0x0002  /* [MF|SIO] invalidate all cached data */
-#define MS_SYNC         0x0010  /* [MF|SIO] msync synchronously */
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define MS_KILLPAGES    0x0004  /* invalidate pages, leave mapped */
-#define MS_DEACTIVATE   0x0008  /* deactivate pages, leave mapped */
-
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-
-/*
- * Advice to madvise
- */
-#define POSIX_MADV_NORMAL       0       /* [MC1] no further special treatment */
-#define POSIX_MADV_RANDOM       1       /* [MC1] expect random page refs */
-#define POSIX_MADV_SEQUENTIAL   2       /* [MC1] expect sequential page refs */
-#define POSIX_MADV_WILLNEED     3       /* [MC1] will need these pages */
-#define POSIX_MADV_DONTNEED     4       /* [MC1] dont need these pages */
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define MADV_NORMAL             POSIX_MADV_NORMAL
-#define MADV_RANDOM             POSIX_MADV_RANDOM
-#define MADV_SEQUENTIAL         POSIX_MADV_SEQUENTIAL
-#define MADV_WILLNEED           POSIX_MADV_WILLNEED
-#define MADV_DONTNEED           POSIX_MADV_DONTNEED
-#define MADV_FREE               5       /* pages unneeded, discard contents */
-#define MADV_ZERO_WIRED_PAGES   6       /* zero the wired pages that have not been unwired before the entry is deleted */
-#define MADV_FREE_REUSABLE      7       /* pages can be reused (by anyone) */
-#define MADV_FREE_REUSE         8       /* caller wants to reuse those pages */
-#define MADV_CAN_REUSE          9
-#define MADV_PAGEOUT            10      /* page out now (internal only) */
-
-/*
- * Return bits from mincore
- */
-#define MINCORE_INCORE           0x1     /* Page is incore */
-#define MINCORE_REFERENCED       0x2     /* Page has been referenced by us */
-#define MINCORE_MODIFIED         0x4     /* Page has been modified by us */
-#define MINCORE_REFERENCED_OTHER 0x8     /* Page has been referenced */
-#define MINCORE_MODIFIED_OTHER  0x10     /* Page has been modified */
-#define MINCORE_PAGED_OUT       0x20     /* Page has been paged out */
-#define MINCORE_COPIED          0x40     /* Page has been copied */
-#define MINCORE_ANONYMOUS       0x80     /* Page belongs to an anonymous object */
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-
-
-__BEGIN_DECLS
-/* [ML] */
-int     mlockall(int);
-int     munlockall(void);
-/* [MR] */
-int     mlock(const void *, size_t);
-#ifndef _MMAP
-#define _MMAP
-/* [MC3]*/
-void *  mmap(void *, size_t, int, int, int, off_t) __DARWIN_ALIAS(mmap);
-#endif
-/* [MPR] */
-int     mprotect(void *, size_t, int) __DARWIN_ALIAS(mprotect);
-/* [MF|SIO] */
-int     msync(void *, size_t, int) __DARWIN_ALIAS_C(msync);
-/* [MR] */
-int     munlock(const void *, size_t);
-/* [MC3]*/
-int     munmap(void *, size_t) __DARWIN_ALIAS(munmap);
-/* [SHM] */
-int     shm_open(const char *, int, ...);
-int     shm_unlink(const char *);
-/* [ADV] */
-int     posix_madvise(void *, size_t, int);
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-int     madvise(void *, size_t, int);
-int     mincore(const void *, size_t, char *);
-int     minherit(void *, size_t, int);
-#endif
-
-
-__END_DECLS
-
-#endif /* !_SYS_MMAN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/param.h b/lib/libc/include/x86_64-macos.10-none/sys/param.h
deleted file mode 100644
index 88330ebbe7..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/param.h
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995, 1997 Apple Computer, Inc. All Rights Reserved */
-/*-
- * Copyright (c) 1982, 1986, 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)param.h	8.3 (Berkeley) 4/4/95
- */
-
-#ifndef _SYS_PARAM_H_
-#define _SYS_PARAM_H_
-
-#define BSD     199506          /* System version (year & month). */
-#define BSD4_3  1
-#define BSD4_4  1
-
-#define NeXTBSD 1995064         /* NeXTBSD version (year, month, release) */
-#define NeXTBSD4_0 0            /* NeXTBSD 4.0 */
-
-#include <sys/_types.h>
-#include <sys/_types/_null.h>
-
-#ifndef LOCORE
-#include <sys/types.h>
-#endif
-
-/*
- * Machine-independent constants (some used in following include files).
- * Redefined constants are from POSIX 1003.1 limits file.
- *
- * MAXCOMLEN should be >= sizeof(ac_comm) (see <acct.h>)
- * MAXLOGNAME should be >= UT_NAMESIZE (see <utmp.h>)
- */
-#include <sys/syslimits.h>
-
-#define MAXCOMLEN       16              /* max command name remembered */
-#define MAXINTERP       64              /* max interpreter file name length */
-#define MAXLOGNAME      255             /* max login name length */
-#define MAXUPRC         CHILD_MAX       /* max simultaneous processes */
-#define NCARGS          ARG_MAX         /* max bytes for an exec function */
-#define NGROUPS         NGROUPS_MAX     /* max number groups */
-#define NOFILE          256             /* default max open files per process */
-#define NOGROUP         65535           /* marker for empty group set member */
-#define MAXHOSTNAMELEN  256             /* max hostname size */
-#define MAXDOMNAMELEN   256             /* maximum domain name length */
-
-/* Machine type dependent parameters. */
-#include <machine/param.h>
-
-/* More types and definitions used throughout the kernel. */
-#include <limits.h>
-
-/* Signals. */
-#include <sys/signal.h>
-
-/*
- * Priorities.  Note that with 32 run queues, differences less than 4 are
- * insignificant.
- */
-#define PSWP    0
-#define PVM     4
-#define PINOD   8
-#define PRIBIO  16
-#define PVFS    20
-#define PZERO   22              /* No longer magic, shouldn't be here.  XXX */
-#define PSOCK   24
-#define PWAIT   32
-#define PLOCK   36
-#define PPAUSE  40
-#define PUSER   50
-#define MAXPRI  127             /* Priorities range from 0 through MAXPRI. */
-
-#define PRIMASK 0x0ff
-#define PCATCH  0x100           /* OR'd with pri for tsleep to check signals */
-#define PTTYBLOCK 0x200         /* for tty SIGTTOU and SIGTTIN blocking */
-#define PDROP   0x400           /* OR'd with pri to stop re-aquistion of mutex upon wakeup */
-#define PSPIN   0x800           /* OR'd with pri to require mutex in spin mode upon wakeup */
-
-#define NBPW    sizeof(int)     /* number of bytes per word (integer) */
-
-#define CMASK   022             /* default file mask: S_IWGRP|S_IWOTH */
-#define NODEV   (dev_t)(-1)     /* non-existent device */
-
-/*
- * Clustering of hardware pages on machines with ridiculously small
- * page sizes is done here.  The paging subsystem deals with units of
- * CLSIZE pte's describing NBPG (from machine/param.h) pages each.
- */
-#define CLBYTES         (CLSIZE*NBPG)
-#define CLOFSET         (CLSIZE*NBPG-1) /* for clusters, like PGOFSET */
-#define claligned(x)    ((((int)(x))&CLOFSET)==0)
-#define CLOFF           CLOFSET
-#define CLSHIFT         (PGSHIFT+CLSIZELOG2)
-
-#if CLSIZE == 1
-#define clbase(i)       (i)
-#define clrnd(i)        (i)
-#else
-/* Give the base virtual address (first of CLSIZE). */
-#define clbase(i)       ((i) &~ (CLSIZE-1))
-/* Round a number of clicks up to a whole cluster. */
-#define clrnd(i)        (((i) + (CLSIZE-1)) &~ (CLSIZE-1))
-#endif
-
-#define CBLOCK  64              /* Clist block size, must be a power of 2. */
-#define CBQSIZE (CBLOCK/NBBY)   /* Quote bytes/cblock - can do better. */
-                                /* Data chars/clist. */
-#define CBSIZE  (CBLOCK - sizeof(struct cblock *) - CBQSIZE)
-#define CROUND  (CBLOCK - 1)    /* Clist rounding. */
-
-/*
- * File system parameters and macros.
- *
- * The file system is made out of blocks of at most MAXPHYS units, with
- * smaller units (fragments) only in the last direct block.  MAXBSIZE
- * primarily determines the size of buffers in the buffer pool.  It may be
- * made larger than MAXPHYS without any effect on existing file systems;
- * however making it smaller may make some file systems unmountable.
- * We set this to track the value of MAX_UPL_TRANSFER_BYTES from
- * osfmk/mach/memory_object_types.h to bound it at the maximum UPL size.
- */
-#define MAXBSIZE        (256 * 4096)
-#define MAXPHYSIO       MAXPHYS
-#define MAXFRAG         8
-
-#define MAXPHYSIO_WIRED (16 * 1024 * 1024)
-
-/*
- * MAXPATHLEN defines the longest permissable path length after expanding
- * symbolic links. It is used to allocate a temporary buffer from the buffer
- * pool in which to do the name expansion, hence should be a power of two,
- * and must be less than or equal to MAXBSIZE.  MAXSYMLINKS defines the
- * maximum number of symbolic links that may be expanded in a path name.
- * It should be set high enough to allow all legitimate uses, but halt
- * infinite loops reasonably quickly.
- */
-#define MAXPATHLEN      PATH_MAX
-#define MAXSYMLINKS     32
-
-/* Bit map related macros. */
-#define setbit(a, i)     (((char *)(a))[(i)/NBBY] |= 1<<((i)%NBBY))
-#define clrbit(a, i)     (((char *)(a))[(i)/NBBY] &= ~(1<<((i)%NBBY)))
-#define isset(a, i)      (((char *)(a))[(i)/NBBY] & (1<<((i)%NBBY)))
-#define isclr(a, i)      ((((char *)(a))[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
-
-/* Macros for counting and rounding. */
-#ifndef howmany
-#define howmany(x, y)   ((((x) % (y)) == 0) ? ((x) / (y)) : (((x) / (y)) + 1))
-#endif
-#define roundup(x, y)   ((((x) % (y)) == 0) ? \
-	                (x) : ((x) + ((y) - ((x) % (y)))))
-#define powerof2(x)     ((((x)-1)&(x))==0)
-
-/* Macros for min/max. */
-#ifndef MIN
-#define MIN(a, b) (((a)<(b))?(a):(b))
-#endif /* MIN */
-#ifndef MAX
-#define MAX(a, b) (((a)>(b))?(a):(b))
-#endif  /* MAX */
-
-/*
- * Constants for setting the parameters of the kernel memory allocator.
- *
- * 2 ** MINBUCKET is the smallest unit of memory that will be
- * allocated. It must be at least large enough to hold a pointer.
- *
- * Units of memory less or equal to MAXALLOCSAVE will permanently
- * allocate physical memory; requests for these size pieces of
- * memory are quite fast. Allocations greater than MAXALLOCSAVE must
- * always allocate and free physical memory; requests for these
- * size allocations should be done infrequently as they will be slow.
- *
- * Constraints: CLBYTES <= MAXALLOCSAVE <= 2 ** (MINBUCKET + 14), and
- * MAXALLOCSIZE must be a power of two.
- */
-#define MINBUCKET       4               /* 4 => min allocation of 16 bytes */
-#define MAXALLOCSAVE    (2 * CLBYTES)
-
-/*
- * Scale factor for scaled integers used to count %cpu time and load avgs.
- *
- * The number of CPU `tick's that map to a unique `%age' can be expressed
- * by the formula (1 / (2 ^ (FSHIFT - 11))).  The maximum load average that
- * can be calculated (assuming 32 bits) can be closely approximated using
- * the formula (2 ^ (2 * (16 - FSHIFT))) for (FSHIFT < 15).
- *
- * For the scheduler to maintain a 1:1 mapping of CPU `tick' to `%age',
- * FSHIFT must be at least 11; this gives us a maximum load avg of ~1024.
- */
-#define FSHIFT  11              /* bits to right of fixed binary point */
-#define FSCALE  (1<<FSHIFT)
-
-#endif  /* _SYS_PARAM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/proc.h b/lib/libc/include/x86_64-macos.10-none/sys/proc.h
deleted file mode 100644
index 56d8b874d5..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/proc.h
+++ /dev/null
@@ -1,223 +0,0 @@
-/*
- * Copyright (c) 2000-2018 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995, 1997 Apple Computer, Inc. All Rights Reserved */
-/*-
- * Copyright (c) 1986, 1989, 1991, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)proc.h	8.15 (Berkeley) 5/19/95
- */
-
-#ifndef _SYS_PROC_H_
-#define _SYS_PROC_H_
-
-#include <sys/appleapiopts.h>
-#include <sys/cdefs.h>
-#include <sys/select.h>                 /* For struct selinfo. */
-#include <sys/queue.h>
-#include <sys/lock.h>
-#include <sys/param.h>
-#include <sys/event.h>
-#include <sys/time.h>
-#include <mach/boolean.h>
-
-
-
-struct session;
-struct pgrp;
-struct proc;
-
-/* Exported fields for kern sysctls */
-struct extern_proc {
-	union {
-		struct {
-			struct  proc *__p_forw; /* Doubly-linked run/sleep queue. */
-			struct  proc *__p_back;
-		} p_st1;
-		struct timeval __p_starttime;   /* process start time */
-	} p_un;
-#define p_forw p_un.p_st1.__p_forw
-#define p_back p_un.p_st1.__p_back
-#define p_starttime p_un.__p_starttime
-	struct  vmspace *p_vmspace;     /* Address space. */
-	struct  sigacts *p_sigacts;     /* Signal actions, state (PROC ONLY). */
-	int     p_flag;                 /* P_* flags. */
-	char    p_stat;                 /* S* process status. */
-	pid_t   p_pid;                  /* Process identifier. */
-	pid_t   p_oppid;         /* Save parent pid during ptrace. XXX */
-	int     p_dupfd;         /* Sideways return value from fdopen. XXX */
-	/* Mach related  */
-	caddr_t user_stack;     /* where user stack was allocated */
-	void    *exit_thread;   /* XXX Which thread is exiting? */
-	int             p_debugger;             /* allow to debug */
-	boolean_t       sigwait;        /* indication to suspend */
-	/* scheduling */
-	u_int   p_estcpu;        /* Time averaged value of p_cpticks. */
-	int     p_cpticks;       /* Ticks of cpu time. */
-	fixpt_t p_pctcpu;        /* %cpu for this process during p_swtime */
-	void    *p_wchan;        /* Sleep address. */
-	char    *p_wmesg;        /* Reason for sleep. */
-	u_int   p_swtime;        /* Time swapped in or out. */
-	u_int   p_slptime;       /* Time since last blocked. */
-	struct  itimerval p_realtimer;  /* Alarm timer. */
-	struct  timeval p_rtime;        /* Real time. */
-	u_quad_t p_uticks;              /* Statclock hits in user mode. */
-	u_quad_t p_sticks;              /* Statclock hits in system mode. */
-	u_quad_t p_iticks;              /* Statclock hits processing intr. */
-	int     p_traceflag;            /* Kernel trace points. */
-	struct  vnode *p_tracep;        /* Trace to vnode. */
-	int     p_siglist;              /* DEPRECATED. */
-	struct  vnode *p_textvp;        /* Vnode of executable. */
-	int     p_holdcnt;              /* If non-zero, don't swap. */
-	sigset_t p_sigmask;     /* DEPRECATED. */
-	sigset_t p_sigignore;   /* Signals being ignored. */
-	sigset_t p_sigcatch;    /* Signals being caught by user. */
-	u_char  p_priority;     /* Process priority. */
-	u_char  p_usrpri;       /* User-priority based on p_cpu and p_nice. */
-	char    p_nice;         /* Process "nice" value. */
-	char    p_comm[MAXCOMLEN + 1];
-	struct  pgrp *p_pgrp;   /* Pointer to process group. */
-	struct  user *p_addr;   /* Kernel virtual addr of u-area (PROC ONLY). */
-	u_short p_xstat;        /* Exit status for wait; also stop signal. */
-	u_short p_acflag;       /* Accounting flags. */
-	struct  rusage *p_ru;   /* Exit information. XXX */
-};
-
-
-/* Status values. */
-#define SIDL    1               /* Process being created by fork. */
-#define SRUN    2               /* Currently runnable. */
-#define SSLEEP  3               /* Sleeping on an address. */
-#define SSTOP   4               /* Process debugging or suspension. */
-#define SZOMB   5               /* Awaiting collection by parent. */
-
-/* These flags are kept in extern_proc.p_flag. */
-#define P_ADVLOCK       0x00000001      /* Process may hold POSIX adv. lock */
-#define P_CONTROLT      0x00000002      /* Has a controlling terminal */
-#define P_LP64          0x00000004      /* Process is LP64 */
-#define P_NOCLDSTOP     0x00000008      /* No SIGCHLD when children stop */
-
-#define P_PPWAIT        0x00000010      /* Parent waiting for chld exec/exit */
-#define P_PROFIL        0x00000020      /* Has started profiling */
-#define P_SELECT        0x00000040      /* Selecting; wakeup/waiting danger */
-#define P_CONTINUED     0x00000080      /* Process was stopped and continued */
-
-#define P_SUGID         0x00000100      /* Has set privileges since last exec */
-#define P_SYSTEM        0x00000200      /* Sys proc: no sigs, stats or swap */
-#define P_TIMEOUT       0x00000400      /* Timing out during sleep */
-#define P_TRACED        0x00000800      /* Debugged process being traced */
-
-#define P_DISABLE_ASLR  0x00001000      /* Disable address space layout randomization */
-#define P_WEXIT         0x00002000      /* Working on exiting */
-#define P_EXEC          0x00004000      /* Process called exec. */
-
-/* Should be moved to machine-dependent areas. */
-#define P_OWEUPC        0x00008000      /* Owe process an addupc() call at next ast. */
-
-#define P_AFFINITY      0x00010000      /* xxx */
-#define P_TRANSLATED    0x00020000      /* xxx */
-#define P_CLASSIC       P_TRANSLATED    /* xxx */
-
-#define P_DELAYIDLESLEEP 0x00040000     /* Process is marked to delay idle sleep on disk IO */
-#define P_CHECKOPENEVT  0x00080000      /* check if a vnode has the OPENEVT flag set on open */
-
-#define P_DEPENDENCY_CAPABLE    0x00100000      /* process is ok to call vfs_markdependency() */
-#define P_REBOOT        0x00200000      /* Process called reboot() */
-#define P_RESV6         0x00400000      /* used to be P_TBE */
-#define P_RESV7         0x00800000      /* (P_SIGEXC)signal exceptions */
-
-#define P_THCWD         0x01000000      /* process has thread cwd  */
-#define P_RESV9         0x02000000      /* (P_VFORK)process has vfork children */
-#define P_ADOPTPERSONA  0x04000000      /* process adopted a persona (used to be P_NOATTACH) */
-#define P_RESV11        0x08000000      /* (P_INVFORK) proc in vfork */
-
-#define P_NOSHLIB       0x10000000      /* no shared libs are in use for proc */
-                                        /* flag set on exec */
-#define P_FORCEQUOTA    0x20000000      /* Force quota for root */
-#define P_NOCLDWAIT     0x40000000      /* No zombies when chil procs exit */
-#define P_NOREMOTEHANG  0x80000000      /* Don't hang on remote FS ops */
-
-#define P_INMEM         0               /* Obsolete: retained for compilation */
-#define P_NOSWAP        0               /* Obsolete: retained for compilation */
-#define P_PHYSIO        0               /* Obsolete: retained for compilation */
-#define P_FSTRACE       0               /* Obsolete: retained for compilation */
-#define P_SSTEP         0               /* Obsolete: retained for compilation */
-
-#define P_DIRTY_TRACK                           0x00000001      /* track dirty state */
-#define P_DIRTY_ALLOW_IDLE_EXIT                 0x00000002      /* process can be idle-exited when clean */
-#define P_DIRTY_DEFER                           0x00000004      /* defer initial opt-in to idle-exit */
-#define P_DIRTY                                 0x00000008      /* process is dirty */
-#define P_DIRTY_SHUTDOWN                        0x00000010      /* process is dirty during shutdown */
-#define P_DIRTY_TERMINATED                      0x00000020      /* process has been marked for termination */
-#define P_DIRTY_BUSY                            0x00000040      /* serialization flag */
-#define P_DIRTY_MARKED                          0x00000080      /* marked dirty previously */
-#define P_DIRTY_AGING_IN_PROGRESS               0x00000100      /* aging in one of the 'aging bands' */
-#define P_DIRTY_LAUNCH_IN_PROGRESS              0x00000200      /* launch is in progress */
-#define P_DIRTY_DEFER_ALWAYS                    0x00000400      /* defer going to idle-exit after every dirty->clean transition.
-	                                                         * For legacy jetsam policy only. This is the default with the other policies.*/
-
-#define P_DIRTY_IS_DIRTY                        (P_DIRTY | P_DIRTY_SHUTDOWN)
-#define P_DIRTY_IDLE_EXIT_ENABLED               (P_DIRTY_TRACK|P_DIRTY_ALLOW_IDLE_EXIT)
-
-
-
-
-#endif  /* !_SYS_PROC_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/shm.h b/lib/libc/include/x86_64-macos.10-none/sys/shm.h
deleted file mode 100644
index 0e5070a03b..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/shm.h
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*	$NetBSD: shm.h,v 1.15 1994/06/29 06:45:17 cgd Exp $	*/
-
-/*
- * Copyright (c) 1994 Adam Glass
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by Adam Glass.
- * 4. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * As defined+described in "X/Open System Interfaces and Headers"
- *                         Issue 4, p. XXX
- */
-
-#ifndef _SYS_SHM_H_
-#define _SYS_SHM_H_
-
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-
-/*
- * [XSI]	All of the symbols from <sys/ipc.h> SHALL be defined
- *		when this header is included
- */
-#include <sys/ipc.h>
-
-/*
- * [XSI] The pid_t, time_t, key_t, and size_t types shall be defined as
- * described in <sys/types.h>.
- *
- * NOTE:	The definition of the key_t type is implicit from the
- *		inclusion of <sys/ipc.h>
- */
-#include <sys/_types/_pid_t.h>
-#include <sys/_types/_time_t.h>
-#include <sys/_types/_size_t.h>
-
-/*
- * [XSI] The unsigned integer type used for the number of current attaches
- * that MUST be able to store values at least as large as a type unsigned
- * short.
- */
-typedef unsigned short  shmatt_t;
-
-
-/*
- * Possible flag values which may be OR'ed into the third argument to
- * shmat()
- */
-#define SHM_RDONLY      010000  /* [XSI] Attach read-only (else read-write) */
-#define SHM_RND         020000  /* [XSI] Round attach address to SHMLBA */
-
-/*
- * This value is symbolic, and generally not expected to be sed by user
- * programs directly, although such ise is permitted by the standard.  Its
- * value in our implementation is equal to the number of bytes per page.
- *
- * NOTE:	We DO NOT obtain this value from the appropriate system
- *		headers at this time, to avoid the resulting namespace
- *		pollution, which is why we discourages its use.
- */
-#define SHMLBA      4096        /* [XSI] Segment low boundary address multiple*/
-
-/* "official" access mode definitions; somewhat braindead since you have
- *  to specify (SHM_* >> 3) for group and (SHM_* >> 6) for world permissions */
-#define SHM_R       (IPC_R)
-#define SHM_W       (IPC_W)
-
-#pragma pack(4)
-
-/*
- * Technically, we should force all code references to the new structure
- * definition, not in just the standards conformance case, and leave the
- * legacy interface there for binary compatibility only.  Currently, we
- * are only forcing this for programs requesting standards conformance.
- */
-#if __DARWIN_UNIX03 || defined(KERNEL)
-/*
- * Structure used internally.
- *
- * This structure is exposed because standards dictate that it is used as
- * the third argment to shmctl().
- *
- * NOTE:	The field shm_internal is not meaningful in user space,
- *		and must not be used there.
- */
-#if (defined(_POSIX_C_SOURCE) && !defined(_DARWIN_C_SOURCE))
-struct shmid_ds
-#else
-#define shmid_ds        __shmid_ds_new
-struct __shmid_ds_new
-#endif
-{
-	struct __ipc_perm_new shm_perm; /* [XSI] Operation permission value */
-	size_t          shm_segsz;      /* [XSI] Size of segment in bytes */
-	pid_t           shm_lpid;       /* [XSI] PID of last shared memory op */
-	pid_t           shm_cpid;       /* [XSI] PID of creator */
-	shmatt_t        shm_nattch;     /* [XSI] Number of current attaches */
-	time_t          shm_atime;      /* [XSI] Time of last shmat() */
-	time_t          shm_dtime;      /* [XSI] Time of last shmdt() */
-	time_t          shm_ctime;      /* [XSI] Time of last shmctl() change */
-	void            *shm_internal;  /* reserved for kernel use */
-};
-#else   /* !__DARWIN_UNIX03 */
-#define shmid_ds        __shmid_ds_old
-#endif  /* !__DARWIN_UNIX03 */
-
-#if !__DARWIN_UNIX03
-struct __shmid_ds_old {
-	struct __ipc_perm_old shm_perm; /* [XSI] Operation permission value */
-	size_t          shm_segsz;      /* [XSI] Size of segment in bytes */
-	pid_t           shm_lpid;       /* [XSI] PID of last shared memory op */
-	pid_t           shm_cpid;       /* [XSI] PID of creator */
-	shmatt_t        shm_nattch;     /* [XSI] Number of current attaches */
-	time_t          shm_atime;      /* [XSI] Time of last shmat() */
-	time_t          shm_dtime;      /* [XSI] Time of last shmdt() */
-	time_t          shm_ctime;      /* [XSI] Time of last shmctl() change */
-	void            *shm_internal;  /* reserved for kernel use */
-};
-#endif  /* !__DARWIN_UNIX03 */
-
-#pragma pack()
-
-
-__BEGIN_DECLS
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-int     shmsys(int, ...);
-#endif /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-void    *shmat(int, const void *, int);
-int     shmctl(int, int, struct shmid_ds *) __DARWIN_ALIAS(shmctl);
-int     shmdt(const void *);
-int     shmget(key_t, size_t, int);
-__END_DECLS
-
-
-#endif /* !_SYS_SHM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/sockio.h b/lib/libc/include/x86_64-macos.10-none/sys/sockio.h
deleted file mode 100644
index c18d55b522..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/sockio.h
+++ /dev/null
@@ -1,180 +0,0 @@
-/*
- * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
-/*-
- * Copyright (c) 1982, 1986, 1990, 1993, 1994
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)sockio.h	8.1 (Berkeley) 3/28/94
- */
-
-#ifndef _SYS_SOCKIO_H_
-#define _SYS_SOCKIO_H_
-
-#include <sys/appleapiopts.h>
-
-#include <sys/ioccom.h>
-
-/* Socket ioctl's. */
-#define SIOCSHIWAT       _IOW('s',  0, int)             /* set high watermark */
-#define SIOCGHIWAT       _IOR('s',  1, int)             /* get high watermark */
-#define SIOCSLOWAT       _IOW('s',  2, int)             /* set low watermark */
-#define SIOCGLOWAT       _IOR('s',  3, int)             /* get low watermark */
-#define SIOCATMARK       _IOR('s',  7, int)             /* at oob mark? */
-#define SIOCSPGRP        _IOW('s',  8, int)             /* set process group */
-#define SIOCGPGRP        _IOR('s',  9, int)             /* get process group */
-
-/*
- * OSIOCGIF* ioctls are deprecated; they are kept for binary compatibility.
- */
-#define SIOCSIFADDR     _IOW('i', 12, struct ifreq)     /* set ifnet address */
-#define SIOCSIFDSTADDR   _IOW('i', 14, struct ifreq)    /* set p-p address */
-#define SIOCSIFFLAGS     _IOW('i', 16, struct ifreq)    /* set ifnet flags */
-#define SIOCGIFFLAGS    _IOWR('i', 17, struct ifreq)    /* get ifnet flags */
-#define SIOCSIFBRDADDR   _IOW('i', 19, struct ifreq)    /* set broadcast addr */
-#define SIOCSIFNETMASK   _IOW('i', 22, struct ifreq)    /* set net addr mask */
-#define SIOCGIFMETRIC   _IOWR('i', 23, struct ifreq)    /* get IF metric */
-#define SIOCSIFMETRIC   _IOW('i', 24, struct ifreq)     /* set IF metric */
-#define SIOCDIFADDR     _IOW('i', 25, struct ifreq)     /* delete IF addr */
-#define SIOCAIFADDR     _IOW('i', 26, struct ifaliasreq)/* add/chg IF alias */
-
-#define SIOCGIFADDR     _IOWR('i', 33, struct ifreq)    /* get ifnet address */
-#define SIOCGIFDSTADDR  _IOWR('i', 34, struct ifreq)    /* get p-p address */
-#define SIOCGIFBRDADDR  _IOWR('i', 35, struct ifreq)    /* get broadcast addr */
-#define SIOCGIFCONF     _IOWR('i', 36, struct ifconf)   /* get ifnet list */
-#define SIOCGIFNETMASK  _IOWR('i', 37, struct ifreq)    /* get net addr mask */
-#define SIOCAUTOADDR    _IOWR('i', 38, struct ifreq)    /* autoconf address */
-#define SIOCAUTONETMASK _IOW('i', 39, struct ifreq)     /* autoconf netmask */
-#define SIOCARPIPLL             _IOWR('i', 40, struct ifreq)    /* arp for IPv4LL address */
-
-#define SIOCADDMULTI     _IOW('i', 49, struct ifreq)    /* add m'cast addr */
-#define SIOCDELMULTI     _IOW('i', 50, struct ifreq)    /* del m'cast addr */
-#define SIOCGIFMTU      _IOWR('i', 51, struct ifreq)    /* get IF mtu */
-#define SIOCSIFMTU       _IOW('i', 52, struct ifreq)    /* set IF mtu */
-#define SIOCGIFPHYS     _IOWR('i', 53, struct ifreq)    /* get IF wire */
-#define SIOCSIFPHYS      _IOW('i', 54, struct ifreq)    /* set IF wire */
-#define SIOCSIFMEDIA    _IOWR('i', 55, struct ifreq)    /* set net media */
-
-/*
- * The command SIOCGIFMEDIA does not allow a process to access the extended
- * media subtype and extended subtype values are returned as IFM_OTHER.
- */
-#define SIOCGIFMEDIA    _IOWR('i', 56, struct ifmediareq) /* get compatible net media  */
-
-#define SIOCSIFGENERIC   _IOW('i', 57, struct ifreq)    /* generic IF set op */
-#define SIOCGIFGENERIC  _IOWR('i', 58, struct ifreq)    /* generic IF get op */
-#define SIOCRSLVMULTI   _IOWR('i', 59, struct rslvmulti_req)
-
-#define SIOCSIFLLADDR   _IOW('i', 60, struct ifreq)     /* set link level addr */
-#define SIOCGIFSTATUS   _IOWR('i', 61, struct ifstat)   /* get IF status */
-#define SIOCSIFPHYADDR   _IOW('i', 62, struct ifaliasreq) /* set gif addres */
-#define SIOCGIFPSRCADDR _IOWR('i', 63, struct ifreq)    /* get gif psrc addr */
-#define SIOCGIFPDSTADDR _IOWR('i', 64, struct ifreq)    /* get gif pdst addr */
-#define SIOCDIFPHYADDR   _IOW('i', 65, struct ifreq)    /* delete gif addrs */
-
-#define SIOCGIFDEVMTU   _IOWR('i', 68, struct ifreq)    /* get if ifdevmtu */
-#define SIOCSIFALTMTU    _IOW('i', 69, struct ifreq)    /* set if alternate mtu */
-#define SIOCGIFALTMTU   _IOWR('i', 72, struct ifreq)    /* get if alternate mtu */
-#define SIOCSIFBOND      _IOW('i', 70, struct ifreq)    /* set bond if config */
-#define SIOCGIFBOND     _IOWR('i', 71, struct ifreq)    /* get bond if config */
-
-/*
- * The command SIOCGIFXMEDIA is meant to be used by processes only to be able
- * to access the extended media subtypes with the extended IFM_TMASK.
- *
- * An ifnet must not implement SIOCGIFXMEDIA as it gets the extended
- * media subtypes by simply compiling with <net/if_media.h>
- */
-#define SIOCGIFXMEDIA   _IOWR('i', 72, struct ifmediareq) /* get net extended media */
-
-
-#define SIOCSIFCAP       _IOW('i', 90, struct ifreq)    /* set IF features */
-#define SIOCGIFCAP      _IOWR('i', 91, struct ifreq)    /* get IF features */
-
-#define SIOCIFCREATE    _IOWR('i', 120, struct ifreq)   /* create clone if */
-#define SIOCIFDESTROY    _IOW('i', 121, struct ifreq)   /* destroy clone if */
-#define SIOCIFCREATE2   _IOWR('i', 122, struct ifreq)   /* create clone if with data */
-
-#define SIOCSDRVSPEC    _IOW('i', 123, struct ifdrv)    /* set driver-specific
-	                                                 *         parameters */
-#define SIOCGDRVSPEC    _IOWR('i', 123, struct ifdrv)   /* get driver-specific
-	                                                 *         parameters */
-#define SIOCSIFVLAN      _IOW('i', 126, struct ifreq)   /* set VLAN config */
-#define SIOCGIFVLAN     _IOWR('i', 127, struct ifreq)   /* get VLAN config */
-#define SIOCSETVLAN     SIOCSIFVLAN
-#define SIOCGETVLAN     SIOCGIFVLAN
-
-#define SIOCIFGCLONERS  _IOWR('i', 129, struct if_clonereq) /* get cloners */
-
-#define SIOCGIFASYNCMAP _IOWR('i', 124, struct ifreq)   /* get ppp asyncmap */
-#define SIOCSIFASYNCMAP _IOW('i', 125, struct ifreq)    /* set ppp asyncmap */
-
-
-
-#define SIOCGIFMAC      _IOWR('i', 130, struct ifreq)   /* get IF MAC label */
-#define SIOCSIFMAC      _IOW('i', 131, struct ifreq)    /* set IF MAC label */
-#define SIOCSIFKPI      _IOW('i', 134, struct ifreq) /* set interface kext param - root only */
-#define SIOCGIFKPI      _IOWR('i', 135, struct ifreq) /* get interface kext param */
-
-#define SIOCGIFWAKEFLAGS _IOWR('i', 136, struct ifreq) /* get interface wake property flags */
-
-#define SIOCGIFFUNCTIONALTYPE   _IOWR('i', 173, struct ifreq) /* get interface functional type */
-
-#define SIOCSIF6LOWPAN  _IOW('i', 196, struct ifreq)    /* set 6LOWPAN config */
-#define SIOCGIF6LOWPAN  _IOWR('i', 197, struct ifreq)   /* get 6LOWPAN config */
-
-
-#endif /* !_SYS_SOCKIO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/syslimits.h b/lib/libc/include/x86_64-macos.10-none/sys/syslimits.h
deleted file mode 100644
index ff60b66ff5..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/syslimits.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*	$NetBSD: syslimits.h,v 1.15 1997/06/25 00:48:09 lukem Exp $	*/
-
-/*
- * Copyright (c) 1988, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)syslimits.h	8.1 (Berkeley) 6/2/93
- */
-
-#ifndef _SYS_SYSLIMITS_H_
-#define _SYS_SYSLIMITS_H_
-
-#include <sys/cdefs.h>
-
-#if !defined(_ANSI_SOURCE)
-/*
- * Note: CHILD_MAX *must* be less than hard_maxproc, which is set at
- * compile time; you *cannot* set it higher than the hard limit!!
- */
-#define ARG_MAX            (256 * 1024) /* max bytes for an exec function */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define CHILD_MAX                  266  /* max simultaneous processes */
-#define GID_MAX            2147483647U  /* max value for a gid_t (2^31-2) */
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-#define LINK_MAX                32767   /* max file link count */
-#define MAX_CANON                1024   /* max bytes in term canon input line */
-#define MAX_INPUT                1024   /* max bytes in terminal input */
-#define NAME_MAX                  255   /* max bytes in a file name */
-#define NGROUPS_MAX                16   /* max supplemental group id's */
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-#define UID_MAX            2147483647U  /* max value for a uid_t (2^31-2) */
-
-#define OPEN_MAX                10240   /* max open files per process - todo, make a config option? */
-
-#endif /* (_POSIX_C_SOURCE && !_DARWIN_C_SOURCE) */
-#define PATH_MAX                 1024   /* max bytes in pathname */
-#define PIPE_BUF                  512   /* max bytes for atomic pipe writes */
-
-#define BC_BASE_MAX                99   /* max ibase/obase values in bc(1) */
-#define BC_DIM_MAX               2048   /* max array elements in bc(1) */
-#define BC_SCALE_MAX               99   /* max scale value in bc(1) */
-#define BC_STRING_MAX            1000   /* max const string length in bc(1) */
-#define CHARCLASS_NAME_MAX         14   /* max character class name size */
-#define COLL_WEIGHTS_MAX            2   /* max weights for order keyword */
-#define EQUIV_CLASS_MAX             2
-#define EXPR_NEST_MAX              32   /* max expressions nested in expr(1) */
-#define LINE_MAX                 2048   /* max bytes in an input line */
-#define RE_DUP_MAX                255   /* max RE's in interval notation */
-
-#if __DARWIN_UNIX03
-#define NZERO                      20   /* default priority [XSI] */
-                                        /* = ((PRIO_MAX - PRIO_MIN) / 2) + 1 */
-                                        /* range: 0 - 39 [(2 * NZERO) - 1] */
-                                        /* 0 is not actually used */
-#else /* !__DARWIN_UNIX03 */
-#define NZERO                       0   /* default priority */
-                                        /* range: -20 - 20 */
-                                        /* (PRIO_MIN - PRIO_MAX) */
-#endif /* __DARWIN_UNIX03 */
-#endif /* !_ANSI_SOURCE */
-
-#endif /* !_SYS_SYSLIMITS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/ttycom.h b/lib/libc/include/x86_64-macos.10-none/sys/ttycom.h
deleted file mode 100644
index e3830c8627..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/ttycom.h
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/* Copyright (c) 1997 Apple Computer, Inc. All Rights Reserved */
-/*-
- * Copyright (c) 1982, 1986, 1990, 1993, 1994
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *      This product includes software developed by the University of
- *      California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)ttycom.h	8.1 (Berkeley) 3/28/94
- */
-
-#ifndef _SYS_TTYCOM_H_
-#define _SYS_TTYCOM_H_
-
-#include <sys/ioccom.h>
-/*
- * Tty ioctl's except for those supported only for backwards compatibility
- * with the old tty driver.
- */
-
-/*
- * Window/terminal size structure.  This information is stored by the kernel
- * in order to provide a consistent interface, but is not used by the kernel.
- */
-struct winsize {
-	unsigned short  ws_row;         /* rows, in characters */
-	unsigned short  ws_col;         /* columns, in characters */
-	unsigned short  ws_xpixel;      /* horizontal size, pixels */
-	unsigned short  ws_ypixel;      /* vertical size, pixels */
-};
-
-#define TIOCMODG        _IOR('t', 3, int)       /* get modem control state */
-#define TIOCMODS        _IOW('t', 4, int)       /* set modem control state */
-#define         TIOCM_LE        0001            /* line enable */
-#define         TIOCM_DTR       0002            /* data terminal ready */
-#define         TIOCM_RTS       0004            /* request to send */
-#define         TIOCM_ST        0010            /* secondary transmit */
-#define         TIOCM_SR        0020            /* secondary receive */
-#define         TIOCM_CTS       0040            /* clear to send */
-#define         TIOCM_CAR       0100            /* carrier detect */
-#define         TIOCM_CD        TIOCM_CAR
-#define         TIOCM_RNG       0200            /* ring */
-#define         TIOCM_RI        TIOCM_RNG
-#define         TIOCM_DSR       0400            /* data set ready */
-                                                /* 8-10 compat */
-#define TIOCEXCL         _IO('t', 13)           /* set exclusive use of tty */
-#define TIOCNXCL         _IO('t', 14)           /* reset exclusive use of tty */
-                                                /* 15 unused */
-#define TIOCFLUSH       _IOW('t', 16, int)      /* flush buffers */
-                                                /* 17-18 compat */
-#define TIOCGETA        _IOR('t', 19, struct termios) /* get termios struct */
-#define TIOCSETA        _IOW('t', 20, struct termios) /* set termios struct */
-#define TIOCSETAW       _IOW('t', 21, struct termios) /* drain output, set */
-#define TIOCSETAF       _IOW('t', 22, struct termios) /* drn out, fls in, set */
-#define TIOCGETD        _IOR('t', 26, int)      /* get line discipline */
-#define TIOCSETD        _IOW('t', 27, int)      /* set line discipline */
-#define TIOCIXON         _IO('t', 129)          /* internal input VSTART */
-#define TIOCIXOFF        _IO('t', 128)          /* internal input VSTOP */
-                                                /* 127-124 compat */
-#define TIOCSBRK         _IO('t', 123)          /* set break bit */
-#define TIOCCBRK         _IO('t', 122)          /* clear break bit */
-#define TIOCSDTR         _IO('t', 121)          /* set data terminal ready */
-#define TIOCCDTR         _IO('t', 120)          /* clear data terminal ready */
-#define TIOCGPGRP       _IOR('t', 119, int)     /* get pgrp of tty */
-#define TIOCSPGRP       _IOW('t', 118, int)     /* set pgrp of tty */
-                                                /* 117-116 compat */
-#define TIOCOUTQ        _IOR('t', 115, int)     /* output queue size */
-#define TIOCSTI         _IOW('t', 114, char)    /* simulate terminal input */
-#define TIOCNOTTY        _IO('t', 113)          /* void tty association */
-#define TIOCPKT         _IOW('t', 112, int)     /* pty: set/clear packet mode */
-#define         TIOCPKT_DATA            0x00    /* data packet */
-#define         TIOCPKT_FLUSHREAD       0x01    /* flush packet */
-#define         TIOCPKT_FLUSHWRITE      0x02    /* flush packet */
-#define         TIOCPKT_STOP            0x04    /* stop output */
-#define         TIOCPKT_START           0x08    /* start output */
-#define         TIOCPKT_NOSTOP          0x10    /* no more ^S, ^Q */
-#define         TIOCPKT_DOSTOP          0x20    /* now do ^S ^Q */
-#define         TIOCPKT_IOCTL           0x40    /* state change of pty driver */
-#define TIOCSTOP         _IO('t', 111)          /* stop output, like ^S */
-#define TIOCSTART        _IO('t', 110)          /* start output, like ^Q */
-#define TIOCMSET        _IOW('t', 109, int)     /* set all modem bits */
-#define TIOCMBIS        _IOW('t', 108, int)     /* bis modem bits */
-#define TIOCMBIC        _IOW('t', 107, int)     /* bic modem bits */
-#define TIOCMGET        _IOR('t', 106, int)     /* get all modem bits */
-#define TIOCREMOTE      _IOW('t', 105, int)     /* remote input editing */
-#define TIOCGWINSZ      _IOR('t', 104, struct winsize)  /* get window size */
-#define TIOCSWINSZ      _IOW('t', 103, struct winsize)  /* set window size */
-#define TIOCUCNTL       _IOW('t', 102, int)     /* pty: set/clr usr cntl mode */
-#define TIOCSTAT         _IO('t', 101)          /* simulate ^T status message */
-#define         UIOCCMD(n)      _IO('u', n)     /* usr cntl op "n" */
-#define TIOCSCONS       _IO('t', 99)            /* 4.2 compatibility */
-#define TIOCCONS        _IOW('t', 98, int)      /* become virtual console */
-#define TIOCSCTTY        _IO('t', 97)           /* become controlling tty */
-#define TIOCEXT         _IOW('t', 96, int)      /* pty: external processing */
-#define TIOCSIG          _IO('t', 95)           /* pty: generate signal */
-#define TIOCDRAIN        _IO('t', 94)           /* wait till output drained */
-#define TIOCMSDTRWAIT   _IOW('t', 91, int)      /* modem: set wait on close */
-#define TIOCMGDTRWAIT   _IOR('t', 90, int)      /* modem: get wait on close */
-#define TIOCTIMESTAMP   _IOR('t', 89, struct timeval)   /* enable/get timestamp
-	                                                 * of last input event */
-#define TIOCDCDTIMESTAMP _IOR('t', 88, struct timeval)  /* enable/get timestamp
-	                                                 * of last DCd rise */
-#define TIOCSDRAINWAIT  _IOW('t', 87, int)      /* set ttywait timeout */
-#define TIOCGDRAINWAIT  _IOR('t', 86, int)      /* get ttywait timeout */
-#define TIOCDSIMICROCODE _IO('t', 85)           /* download microcode to
-	                                         * DSI Softmodem */
-#define TIOCPTYGRANT    _IO('t', 84)            /* grantpt(3) */
-#define TIOCPTYGNAME    _IOC(IOC_OUT, 't', 83, 128)     /* ptsname(3) */
-#define TIOCPTYUNLK     _IO('t', 82)            /* unlockpt(3) */
-
-#define TTYDISC         0               /* termios tty line discipline */
-#define TABLDISC        3               /* tablet discipline */
-#define SLIPDISC        4               /* serial IP discipline */
-#define PPPDISC         5               /* PPP discipline */
-
-#endif /* !_SYS_TTYCOM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/ucontext.h b/lib/libc/include/x86_64-macos.10-none/sys/ucontext.h
deleted file mode 100644
index e4468f2e40..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/ucontext.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2002-2006 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-
-#ifndef _SYS_UCONTEXT_H_
-#define _SYS_UCONTEXT_H_
-
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-
-#include <machine/_mcontext.h>
-#include <sys/_types/_sigaltstack.h>
-#include <sys/_types/_ucontext.h>
-
-#include <sys/_types/_sigset_t.h>
-
-
-#endif /* _SYS_UCONTEXT_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/sys/un.h b/lib/libc/include/x86_64-macos.10-none/sys/un.h
deleted file mode 100644
index a27ead5406..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/sys/un.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
- *
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. The rights granted to you under the License
- * may not be used to create, or enable the creation or redistribution of,
- * unlawful or unlicensed copies of an Apple operating system, or to
- * circumvent, violate, or enable the circumvention or violation of, any
- * terms of an Apple operating system software license agreement.
- *
- * Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this file.
- *
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- *
- * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
- */
-/*
- * Copyright (c) 1982, 1986, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)un.h	8.3 (Berkeley) 2/19/95
- */
-
-#ifndef _SYS_UN_H_
-#define _SYS_UN_H_
-
-#include <sys/appleapiopts.h>
-#include <sys/cdefs.h>
-#include <sys/_types.h>
-
-/* [XSI] The sa_family_t type shall be defined as described in <sys/socket.h> */
-#include <sys/_types/_sa_family_t.h>
-
-/*
- * [XSI] Definitions for UNIX IPC domain.
- */
-struct  sockaddr_un {
-	unsigned char   sun_len;        /* sockaddr len including null */
-	sa_family_t     sun_family;     /* [XSI] AF_UNIX */
-	char            sun_path[104];  /* [XSI] path name (gag) */
-};
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-
-/* Level number of get/setsockopt for local domain sockets */
-#define SOL_LOCAL               0
-
-/* Socket options. */
-#define LOCAL_PEERCRED          0x001           /* retrieve peer credentials */
-#define LOCAL_PEERPID           0x002           /* retrieve peer pid */
-#define LOCAL_PEEREPID          0x003           /* retrieve eff. peer pid */
-#define LOCAL_PEERUUID          0x004           /* retrieve peer UUID */
-#define LOCAL_PEEREUUID         0x005           /* retrieve eff. peer UUID */
-
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-/* actual length of an initialized sockaddr_un */
-#define SUN_LEN(su) \
-	(sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
-#endif  /* (!_POSIX_C_SOURCE || _DARWIN_C_SOURCE) */
-
-
-#endif /* !_SYS_UN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/time.h b/lib/libc/include/x86_64-macos.10-none/time.h
deleted file mode 100644
index b2edfb95cd..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/time.h
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-/*
- * Copyright (c) 1989, 1993
- *	The Regents of the University of California.  All rights reserved.
- * (c) UNIX System Laboratories, Inc.
- * All or some portions of this file are derived from material licensed
- * to the University of California by American Telephone and Telegraph
- * Co. or Unix System Laboratories, Inc. and are reproduced herein with
- * the permission of UNIX System Laboratories, Inc.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)time.h	8.3 (Berkeley) 1/21/94
- */
-
-#ifndef _TIME_H_
-#define	_TIME_H_
-
-#include <_types.h>
-#include <sys/cdefs.h>
-#include <Availability.h>
-#include <sys/_types/_clock_t.h>
-#include <sys/_types/_null.h>
-#include <sys/_types/_size_t.h>
-#include <sys/_types/_time_t.h>
-#include <sys/_types/_timespec.h>
-
-struct tm {
-	int	tm_sec;		/* seconds after the minute [0-60] */
-	int	tm_min;		/* minutes after the hour [0-59] */
-	int	tm_hour;	/* hours since midnight [0-23] */
-	int	tm_mday;	/* day of the month [1-31] */
-	int	tm_mon;		/* months since January [0-11] */
-	int	tm_year;	/* years since 1900 */
-	int	tm_wday;	/* days since Sunday [0-6] */
-	int	tm_yday;	/* days since January 1 [0-365] */
-	int	tm_isdst;	/* Daylight Savings Time flag */
-	long	tm_gmtoff;	/* offset from UTC in seconds */
-	char	*tm_zone;	/* timezone abbreviation */
-};
-
-#if __DARWIN_UNIX03
-#define CLOCKS_PER_SEC  1000000	/* [XSI] */
-#else /* !__DARWIN_UNIX03 */
-#include <machine/_limits.h>	/* Include file containing CLK_TCK. */
-
-#define CLOCKS_PER_SEC  (__DARWIN_CLK_TCK)
-#endif /* __DARWIN_UNIX03 */
-
-#ifndef _ANSI_SOURCE
-extern char *tzname[];
-#endif
-
-extern int getdate_err;
-#if __DARWIN_UNIX03
-extern long timezone __DARWIN_ALIAS(timezone);
-#endif /* __DARWIN_UNIX03 */
-extern int daylight;
-
-__BEGIN_DECLS
-char *asctime(const struct tm *);
-clock_t clock(void) __DARWIN_ALIAS(clock);
-char *ctime(const time_t *);
-double difftime(time_t, time_t);
-struct tm *getdate(const char *);
-struct tm *gmtime(const time_t *);
-struct tm *localtime(const time_t *);
-time_t mktime(struct tm *) __DARWIN_ALIAS(mktime);
-size_t strftime(char * __restrict, size_t, const char * __restrict, const struct tm * __restrict) __DARWIN_ALIAS(strftime);
-char *strptime(const char * __restrict, const char * __restrict, struct tm * __restrict) __DARWIN_ALIAS(strptime);
-time_t time(time_t *);
-
-#ifndef _ANSI_SOURCE
-void tzset(void);
-#endif /* not ANSI */
-
-/* [TSF] Thread safe functions */
-char *asctime_r(const struct tm * __restrict, char * __restrict);
-char *ctime_r(const time_t *, char *);
-struct tm *gmtime_r(const time_t * __restrict, struct tm * __restrict);
-struct tm *localtime_r(const time_t * __restrict, struct tm * __restrict);
-
-#if !defined(_ANSI_SOURCE) && (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE))
-time_t posix2time(time_t);
-#if !__DARWIN_UNIX03
-char *timezone(int, int);
-#endif /* !__DARWIN_UNIX03 */
-void tzsetwall(void);
-time_t time2posix(time_t);
-time_t timelocal(struct tm * const);
-time_t timegm(struct tm * const);
-#endif /* neither ANSI nor POSIX */
-
-#if !defined(_ANSI_SOURCE)
-int nanosleep(const struct timespec *__rqtp, struct timespec *__rmtp) __DARWIN_ALIAS_C(nanosleep);
-#endif
-
-#if !defined(_DARWIN_FEATURE_CLOCK_GETTIME) || _DARWIN_FEATURE_CLOCK_GETTIME != 0
-#if __DARWIN_C_LEVEL >= 199309L
-#if __has_feature(enumerator_attributes)
-#define __CLOCK_AVAILABILITY __OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0) __TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0)
-#else
-#define __CLOCK_AVAILABILITY
-#endif
-
-typedef enum {
-_CLOCK_REALTIME __CLOCK_AVAILABILITY = 0,
-#define CLOCK_REALTIME _CLOCK_REALTIME
-_CLOCK_MONOTONIC __CLOCK_AVAILABILITY = 6,
-#define CLOCK_MONOTONIC _CLOCK_MONOTONIC
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-_CLOCK_MONOTONIC_RAW __CLOCK_AVAILABILITY = 4,
-#define CLOCK_MONOTONIC_RAW _CLOCK_MONOTONIC_RAW
-_CLOCK_MONOTONIC_RAW_APPROX __CLOCK_AVAILABILITY = 5,
-#define CLOCK_MONOTONIC_RAW_APPROX _CLOCK_MONOTONIC_RAW_APPROX
-_CLOCK_UPTIME_RAW __CLOCK_AVAILABILITY = 8,
-#define CLOCK_UPTIME_RAW _CLOCK_UPTIME_RAW
-_CLOCK_UPTIME_RAW_APPROX __CLOCK_AVAILABILITY = 9,
-#define CLOCK_UPTIME_RAW_APPROX _CLOCK_UPTIME_RAW_APPROX
-#endif
-_CLOCK_PROCESS_CPUTIME_ID __CLOCK_AVAILABILITY = 12,
-#define CLOCK_PROCESS_CPUTIME_ID _CLOCK_PROCESS_CPUTIME_ID
-_CLOCK_THREAD_CPUTIME_ID __CLOCK_AVAILABILITY = 16
-#define CLOCK_THREAD_CPUTIME_ID _CLOCK_THREAD_CPUTIME_ID
-} clockid_t;
-
-__CLOCK_AVAILABILITY
-int clock_getres(clockid_t __clock_id, struct timespec *__res);
-
-__CLOCK_AVAILABILITY
-int clock_gettime(clockid_t __clock_id, struct timespec *__tp);
-
-#if !defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)
-__CLOCK_AVAILABILITY
-__uint64_t clock_gettime_nsec_np(clockid_t __clock_id);
-#endif
-
-__OSX_AVAILABLE(10.12) __IOS_PROHIBITED
-__TVOS_PROHIBITED __WATCHOS_PROHIBITED
-int clock_settime(clockid_t __clock_id, const struct timespec *__tp);
-
-#undef __CLOCK_AVAILABILITY
-#endif /* __DARWIN_C_LEVEL */
-#endif /* _DARWIN_FEATURE_CLOCK_GETTIME */
-
-#if (__DARWIN_C_LEVEL >= __DARWIN_C_FULL) && \
-        ((defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || \
-        (defined(__cplusplus) && __cplusplus >= 201703L))
-/* ISO/IEC 9899:201x 7.27.2.5 The timespec_get function */
-#define TIME_UTC	1	/* time elapsed since epoch */
-__API_AVAILABLE(macosx(10.15), ios(13.0), tvos(13.0), watchos(6.0))
-int timespec_get(struct timespec *ts, int base);
-#endif
-
-__END_DECLS
-
-#ifdef _USE_EXTENDED_LOCALES_
-#include <xlocale/_time.h>
-#endif /* _USE_EXTENDED_LOCALES_ */
-
-#endif /* !_TIME_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/ucontext.h b/lib/libc/include/x86_64-macos.10-none/ucontext.h
deleted file mode 100644
index 32ffa65b7e..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/ucontext.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright (c) 2002, 2008, 2009 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-/*
- * These routines are DEPRECATED and should not be used.
- */
-#ifndef _UCONTEXT_H_
-#define _UCONTEXT_H_
-
-#include <sys/cdefs.h>
-
-#ifdef _XOPEN_SOURCE
-#include <sys/ucontext.h>
-#include <Availability.h>
-
-__BEGIN_DECLS
-int  getcontext(ucontext_t *) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_2_0, __IPHONE_2_0) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-void makecontext(ucontext_t *, void (*)(), int, ...) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_2_0, __IPHONE_2_0) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-int  setcontext(const ucontext_t *) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_2_0, __IPHONE_2_0) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-int  swapcontext(ucontext_t * __restrict, const ucontext_t * __restrict) __OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5, __MAC_10_6, __IPHONE_2_0, __IPHONE_2_0) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-__END_DECLS
-#else /* !_XOPEN_SOURCE */
-#error The deprecated ucontext routines require _XOPEN_SOURCE to be defined
-#endif /* _XOPEN_SOURCE */
-
-#endif /* _UCONTEXT_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/unistd.h b/lib/libc/include/x86_64-macos.10-none/unistd.h
deleted file mode 100644
index d07a4a61f5..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/unistd.h
+++ /dev/null
@@ -1,787 +0,0 @@
-/*
- * Copyright (c) 2000, 2002-2006, 2008-2010, 2012 Apple Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-/*-
- * Copyright (c) 1998-1999 Apple Computer, Inc. All Rights Reserved
- * Copyright (c) 1991, 1993, 1994
- *	The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)unistd.h	8.12 (Berkeley) 4/27/95
- *
- *  Copyright (c)  1998 Apple Compter, Inc.
- *  All Rights Reserved
- */
-
-/* History:
-        7/14/99 EKN at Apple fixed getdirentriesattr from getdirentryattr
-        3/26/98 CHW at Apple added real interface to searchfs call
-  	3/5/98  CHW at Apple added hfs semantic system calls headers
-*/
-
-#ifndef _UNISTD_H_
-#define	_UNISTD_H_
-
-#include <_types.h>
-#include <sys/unistd.h>
-#include <Availability.h>
-#include <sys/_types/_gid_t.h>
-#include <sys/_types/_intptr_t.h>
-#include <sys/_types/_off_t.h>
-#include <sys/_types/_pid_t.h>
-/* DO NOT REMOVE THIS COMMENT: fixincludes needs to see:
- * _GCC_SIZE_T */
-#include <sys/_types/_size_t.h>
-#include <sys/_types/_ssize_t.h>
-#include <sys/_types/_uid_t.h>
-#include <sys/_types/_useconds_t.h>
-#include <sys/_types/_null.h>
-
-#define	 STDIN_FILENO	0	/* standard input file descriptor */
-#define	STDOUT_FILENO	1	/* standard output file descriptor */
-#define	STDERR_FILENO	2	/* standard error file descriptor */
-
-
-/* Version test macros */
-/* _POSIX_VERSION and _POSIX2_VERSION from sys/unistd.h */
-#define	_XOPEN_VERSION			600		/* [XSI] */
-#define	_XOPEN_XCU_VERSION		4		/* Older standard */
-
-
-/* Please keep this list in the same order as the applicable standard */
-#define	_POSIX_ADVISORY_INFO		(-1)		/* [ADV] */
-#define	_POSIX_ASYNCHRONOUS_IO		(-1)		/* [AIO] */
-#define	_POSIX_BARRIERS			(-1)		/* [BAR] */
-#define	_POSIX_CHOWN_RESTRICTED		200112L
-#define	_POSIX_CLOCK_SELECTION		(-1)		/* [CS] */
-#define	_POSIX_CPUTIME			(-1)		/* [CPT] */
-#define	_POSIX_FSYNC			200112L		/* [FSC] */
-#define	_POSIX_IPV6			200112L
-#define	_POSIX_JOB_CONTROL		200112L
-#define	_POSIX_MAPPED_FILES		200112L		/* [MF] */
-#define	_POSIX_MEMLOCK			(-1)		/* [ML] */
-#define	_POSIX_MEMLOCK_RANGE		(-1)		/* [MR] */
-#define	_POSIX_MEMORY_PROTECTION	200112L		/* [MPR] */
-#define	_POSIX_MESSAGE_PASSING		(-1)		/* [MSG] */
-#define	_POSIX_MONOTONIC_CLOCK		(-1)		/* [MON] */
-#define	_POSIX_NO_TRUNC			200112L
-#define	_POSIX_PRIORITIZED_IO		(-1)		/* [PIO] */
-#define	_POSIX_PRIORITY_SCHEDULING	(-1)		/* [PS] */
-#define	_POSIX_RAW_SOCKETS		(-1)		/* [RS] */
-#define	_POSIX_READER_WRITER_LOCKS	200112L		/* [THR] */
-#define	_POSIX_REALTIME_SIGNALS		(-1)		/* [RTS] */
-#define	_POSIX_REGEXP			200112L
-#define	_POSIX_SAVED_IDS		200112L		/* XXX required */
-#define	_POSIX_SEMAPHORES		(-1)		/* [SEM] */
-#define	_POSIX_SHARED_MEMORY_OBJECTS	(-1)		/* [SHM] */
-#define	_POSIX_SHELL			200112L
-#define	_POSIX_SPAWN			(-1)		/* [SPN] */
-#define	_POSIX_SPIN_LOCKS		(-1)		/* [SPI] */
-#define	_POSIX_SPORADIC_SERVER		(-1)		/* [SS] */
-#define	_POSIX_SYNCHRONIZED_IO		(-1)		/* [SIO] */
-#define	_POSIX_THREAD_ATTR_STACKADDR	200112L		/* [TSA] */
-#define	_POSIX_THREAD_ATTR_STACKSIZE	200112L		/* [TSS] */
-#define	_POSIX_THREAD_CPUTIME		(-1)		/* [TCT] */
-#define	_POSIX_THREAD_PRIO_INHERIT	(-1)		/* [TPI] */
-#define	_POSIX_THREAD_PRIO_PROTECT	(-1)		/* [TPP] */
-#define	_POSIX_THREAD_PRIORITY_SCHEDULING	(-1)	/* [TPS] */
-#define	_POSIX_THREAD_PROCESS_SHARED	200112L		/* [TSH] */
-#define	_POSIX_THREAD_SAFE_FUNCTIONS	200112L		/* [TSF] */
-#define	_POSIX_THREAD_SPORADIC_SERVER	(-1)		/* [TSP] */
-#define	_POSIX_THREADS			200112L		/* [THR] */
-#define	_POSIX_TIMEOUTS			(-1)		/* [TMO] */
-#define	_POSIX_TIMERS			(-1)		/* [TMR] */
-#define	_POSIX_TRACE			(-1)		/* [TRC] */
-#define	_POSIX_TRACE_EVENT_FILTER	(-1)		/* [TEF] */
-#define	_POSIX_TRACE_INHERIT		(-1)		/* [TRI] */
-#define	_POSIX_TRACE_LOG		(-1)		/* [TRL] */
-#define	_POSIX_TYPED_MEMORY_OBJECTS	(-1)		/* [TYM] */
-#ifndef _POSIX_VDISABLE
-#define	_POSIX_VDISABLE			0xff		/* same as sys/termios.h */
-#endif /* _POSIX_VDISABLE */
-
-#if __DARWIN_C_LEVEL >= 199209L
-#define	_POSIX2_C_BIND			200112L
-#define	_POSIX2_C_DEV			200112L		/* c99 command */
-#define	_POSIX2_CHAR_TERM		200112L
-#define	_POSIX2_FORT_DEV		(-1)		/* fort77 command */
-#define	_POSIX2_FORT_RUN		200112L
-#define	_POSIX2_LOCALEDEF		200112L		/* localedef command */
-#define	_POSIX2_PBS			(-1)
-#define	_POSIX2_PBS_ACCOUNTING		(-1)
-#define	_POSIX2_PBS_CHECKPOINT		(-1)
-#define	_POSIX2_PBS_LOCATE		(-1)
-#define	_POSIX2_PBS_MESSAGE		(-1)
-#define	_POSIX2_PBS_TRACK		(-1)
-#define	_POSIX2_SW_DEV			200112L
-#define	_POSIX2_UPE			200112L	/* XXXX no fc, newgrp, tabs */
-#endif /* __DARWIN_C_LEVEL */
-
-#define	__ILP32_OFF32          (-1)
-#define	__ILP32_OFFBIG         (-1)
-
-#define	__LP64_OFF64           (1)
-#define	__LPBIG_OFFBIG         (1)
-
-#if __DARWIN_C_LEVEL >= 200112L
-#define	_POSIX_V6_ILP32_OFF32		__ILP32_OFF32
-#define	_POSIX_V6_ILP32_OFFBIG		__ILP32_OFFBIG
-#define	_POSIX_V6_LP64_OFF64		__LP64_OFF64
-#define	_POSIX_V6_LPBIG_OFFBIG		__LPBIG_OFFBIG
-#endif /* __DARWIN_C_LEVEL >= 200112L */
-
-#if __DARWIN_C_LEVEL >= 200809L
-#define	_POSIX_V7_ILP32_OFF32		__ILP32_OFF32
-#define	_POSIX_V7_ILP32_OFFBIG		__ILP32_OFFBIG
-#define	_POSIX_V7_LP64_OFF64		__LP64_OFF64
-#define	_POSIX_V7_LPBIG_OFFBIG		__LPBIG_OFFBIG
-#endif /* __DARWIN_C_LEVEL >= 200809L */
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#define	_V6_ILP32_OFF32             __ILP32_OFF32
-#define	_V6_ILP32_OFFBIG            __ILP32_OFFBIG
-#define	_V6_LP64_OFF64              __LP64_OFF64
-#define	_V6_LPBIG_OFFBIG            __LPBIG_OFFBIG
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-#if (__DARWIN_C_LEVEL >= 199506L && __DARWIN_C_LEVEL < 200809L) || __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-/* Removed in Issue 7 */
-#define	_XBS5_ILP32_OFF32		    __ILP32_OFF32
-#define	_XBS5_ILP32_OFFBIG		    __ILP32_OFFBIG
-#define	_XBS5_LP64_OFF64		    __LP64_OFF64
-#define	_XBS5_LPBIG_OFFBIG		    __LPBIG_OFFBIG
-#endif /* __DARWIN_C_LEVEL < 200809L */
-
-#if __DARWIN_C_LEVEL >= 199506L /* This really should be XSI */ 
-#define	_XOPEN_CRYPT			(1)
-#define	_XOPEN_ENH_I18N			(1)		/* XXX required */
-#define	_XOPEN_LEGACY			(-1)	/* no ftime gcvt, wcswcs */
-#define	_XOPEN_REALTIME			(-1)	/* no q'ed signals, mq_* */
-#define	_XOPEN_REALTIME_THREADS		(-1)	/* no posix_spawn, et. al. */
-#define	_XOPEN_SHM			(1)
-#define	_XOPEN_STREAMS			(-1)   /* Issue 6 */
-#define	_XOPEN_UNIX			(1)
-#endif /* XSI */
-
-/* configurable system variables */
-#define	_SC_ARG_MAX			 1
-#define	_SC_CHILD_MAX			 2
-#define	_SC_CLK_TCK			 3
-#define	_SC_NGROUPS_MAX			 4
-#define	_SC_OPEN_MAX			 5
-#define	_SC_JOB_CONTROL			 6
-#define	_SC_SAVED_IDS			 7
-#define	_SC_VERSION			 8
-#define	_SC_BC_BASE_MAX			 9
-#define	_SC_BC_DIM_MAX			10
-#define	_SC_BC_SCALE_MAX		11
-#define	_SC_BC_STRING_MAX		12
-#define	_SC_COLL_WEIGHTS_MAX		13
-#define	_SC_EXPR_NEST_MAX		14
-#define	_SC_LINE_MAX			15
-#define	_SC_RE_DUP_MAX			16
-#define	_SC_2_VERSION			17
-#define	_SC_2_C_BIND			18
-#define	_SC_2_C_DEV			19
-#define	_SC_2_CHAR_TERM			20
-#define	_SC_2_FORT_DEV			21
-#define	_SC_2_FORT_RUN			22
-#define	_SC_2_LOCALEDEF			23
-#define	_SC_2_SW_DEV			24
-#define	_SC_2_UPE			25
-#define	_SC_STREAM_MAX			26
-#define	_SC_TZNAME_MAX			27
-
-#if __DARWIN_C_LEVEL >= 199309L
-#define	_SC_ASYNCHRONOUS_IO		28
-#define	_SC_PAGESIZE			29
-#define	_SC_MEMLOCK			30
-#define	_SC_MEMLOCK_RANGE		31
-#define	_SC_MEMORY_PROTECTION		32
-#define	_SC_MESSAGE_PASSING		33
-#define	_SC_PRIORITIZED_IO		34
-#define	_SC_PRIORITY_SCHEDULING		35
-#define	_SC_REALTIME_SIGNALS		36
-#define	_SC_SEMAPHORES			37
-#define	_SC_FSYNC			38
-#define	_SC_SHARED_MEMORY_OBJECTS 	39
-#define	_SC_SYNCHRONIZED_IO		40
-#define	_SC_TIMERS			41
-#define	_SC_AIO_LISTIO_MAX		42
-#define	_SC_AIO_MAX			43
-#define	_SC_AIO_PRIO_DELTA_MAX		44
-#define	_SC_DELAYTIMER_MAX		45
-#define	_SC_MQ_OPEN_MAX			46
-#define	_SC_MAPPED_FILES		47	/* swap _SC_PAGESIZE vs. BSD */
-#define	_SC_RTSIG_MAX			48
-#define	_SC_SEM_NSEMS_MAX		49
-#define	_SC_SEM_VALUE_MAX		50
-#define	_SC_SIGQUEUE_MAX		51
-#define	_SC_TIMER_MAX			52
-#endif /* __DARWIN_C_LEVEL >= 199309L */
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#define	_SC_NPROCESSORS_CONF		57
-#define	_SC_NPROCESSORS_ONLN		58
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-#if __DARWIN_C_LEVEL >= 200112L
-#define	_SC_2_PBS			59
-#define	_SC_2_PBS_ACCOUNTING		60
-#define	_SC_2_PBS_CHECKPOINT		61
-#define	_SC_2_PBS_LOCATE		62
-#define	_SC_2_PBS_MESSAGE		63
-#define	_SC_2_PBS_TRACK			64
-#define	_SC_ADVISORY_INFO		65
-#define	_SC_BARRIERS			66
-#define	_SC_CLOCK_SELECTION		67
-#define	_SC_CPUTIME			68
-#define	_SC_FILE_LOCKING		69
-#define	_SC_GETGR_R_SIZE_MAX		70
-#define	_SC_GETPW_R_SIZE_MAX		71
-#define	_SC_HOST_NAME_MAX		72
-#define	_SC_LOGIN_NAME_MAX		73
-#define	_SC_MONOTONIC_CLOCK		74
-#define	_SC_MQ_PRIO_MAX			75
-#define	_SC_READER_WRITER_LOCKS		76
-#define	_SC_REGEXP			77
-#define	_SC_SHELL			78
-#define	_SC_SPAWN			79
-#define	_SC_SPIN_LOCKS			80
-#define	_SC_SPORADIC_SERVER		81
-#define	_SC_THREAD_ATTR_STACKADDR	82
-#define	_SC_THREAD_ATTR_STACKSIZE	83
-#define	_SC_THREAD_CPUTIME		84
-#define	_SC_THREAD_DESTRUCTOR_ITERATIONS 85
-#define	_SC_THREAD_KEYS_MAX		86
-#define	_SC_THREAD_PRIO_INHERIT		87
-#define	_SC_THREAD_PRIO_PROTECT		88
-#define	_SC_THREAD_PRIORITY_SCHEDULING	89
-#define	_SC_THREAD_PROCESS_SHARED	90
-#define	_SC_THREAD_SAFE_FUNCTIONS	91
-#define	_SC_THREAD_SPORADIC_SERVER	92
-#define	_SC_THREAD_STACK_MIN		93
-#define	_SC_THREAD_THREADS_MAX		94
-#define	_SC_TIMEOUTS			95
-#define	_SC_THREADS			96
-#define	_SC_TRACE			97
-#define	_SC_TRACE_EVENT_FILTER		98
-#define	_SC_TRACE_INHERIT		99
-#define	_SC_TRACE_LOG			100
-#define	_SC_TTY_NAME_MAX		101
-#define	_SC_TYPED_MEMORY_OBJECTS	102
-#define	_SC_V6_ILP32_OFF32		103
-#define	_SC_V6_ILP32_OFFBIG		104
-#define	_SC_V6_LP64_OFF64		105
-#define	_SC_V6_LPBIG_OFFBIG		106
-#define	_SC_IPV6			118
-#define	_SC_RAW_SOCKETS			119
-#define	_SC_SYMLOOP_MAX			120
-#endif /* __DARWIN_C_LEVEL >= 200112L */
-
-#if __DARWIN_C_LEVEL >= 199506L /* Really XSI */
-#define	_SC_ATEXIT_MAX			107
-#define	_SC_IOV_MAX			56
-#define	_SC_PAGE_SIZE			_SC_PAGESIZE
-#define	_SC_XOPEN_CRYPT			108
-#define	_SC_XOPEN_ENH_I18N		109
-#define	_SC_XOPEN_LEGACY		110      /* Issue 6 */
-#define	_SC_XOPEN_REALTIME		111      /* Issue 6 */
-#define	_SC_XOPEN_REALTIME_THREADS	112  /* Issue 6 */
-#define	_SC_XOPEN_SHM			113
-#define	_SC_XOPEN_STREAMS		114      /* Issue 6 */
-#define	_SC_XOPEN_UNIX			115
-#define	_SC_XOPEN_VERSION		116
-#define	_SC_XOPEN_XCU_VERSION		121
-#endif /* XSI */
-
-#if (__DARWIN_C_LEVEL >= 199506L && __DARWIN_C_LEVEL < 200809L) || __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-/* Removed in Issue 7 */
-#define	_SC_XBS5_ILP32_OFF32		122
-#define	_SC_XBS5_ILP32_OFFBIG		123
-#define	_SC_XBS5_LP64_OFF64		124
-#define	_SC_XBS5_LPBIG_OFFBIG		125
-#endif /* __DARWIN_C_LEVEL <= 200809L */
-
-#if __DARWIN_C_LEVEL >= 200112L
-#define	_SC_SS_REPL_MAX			126
-#define	_SC_TRACE_EVENT_NAME_MAX	127
-#define	_SC_TRACE_NAME_MAX		128
-#define	_SC_TRACE_SYS_MAX		129
-#define	_SC_TRACE_USER_EVENT_MAX	130
-#endif
-
-#if __DARWIN_C_LEVEL < 200112L || __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-/* Removed in Issue 6 */
-#define	_SC_PASS_MAX			131
-#endif
-
-/* 132-199 available for future use */
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#define	_SC_PHYS_PAGES			200
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-#if __DARWIN_C_LEVEL >= 199209L
-#ifndef _CS_PATH /* Defined in <sys/unistd.h> */
-#define	_CS_PATH				1
-#endif
-#endif
-
-#if __DARWIN_C_LEVEL >= 200112
-#define	_CS_POSIX_V6_ILP32_OFF32_CFLAGS		2
-#define	_CS_POSIX_V6_ILP32_OFF32_LDFLAGS	3
-#define	_CS_POSIX_V6_ILP32_OFF32_LIBS		4
-#define	_CS_POSIX_V6_ILP32_OFFBIG_CFLAGS	5
-#define	_CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS	6
-#define	_CS_POSIX_V6_ILP32_OFFBIG_LIBS		7
-#define	_CS_POSIX_V6_LP64_OFF64_CFLAGS		8
-#define	_CS_POSIX_V6_LP64_OFF64_LDFLAGS		9
-#define	_CS_POSIX_V6_LP64_OFF64_LIBS		10
-#define	_CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS	11
-#define	_CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS	12
-#define	_CS_POSIX_V6_LPBIG_OFFBIG_LIBS		13
-#define	_CS_POSIX_V6_WIDTH_RESTRICTED_ENVS	14
-#endif
-
-#if (__DARWIN_C_LEVEL >= 199506L && __DARWIN_C_LEVEL < 200809L) || __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-/* Removed in Issue 7 */
-#define	_CS_XBS5_ILP32_OFF32_CFLAGS		20
-#define	_CS_XBS5_ILP32_OFF32_LDFLAGS		21
-#define	_CS_XBS5_ILP32_OFF32_LIBS		22
-#define	_CS_XBS5_ILP32_OFF32_LINTFLAGS		23
-#define	_CS_XBS5_ILP32_OFFBIG_CFLAGS		24
-#define	_CS_XBS5_ILP32_OFFBIG_LDFLAGS		25
-#define	_CS_XBS5_ILP32_OFFBIG_LIBS		26
-#define	_CS_XBS5_ILP32_OFFBIG_LINTFLAGS		27
-#define	_CS_XBS5_LP64_OFF64_CFLAGS		28
-#define	_CS_XBS5_LP64_OFF64_LDFLAGS		29
-#define	_CS_XBS5_LP64_OFF64_LIBS		30
-#define	_CS_XBS5_LP64_OFF64_LINTFLAGS		31
-#define	_CS_XBS5_LPBIG_OFFBIG_CFLAGS		32
-#define	_CS_XBS5_LPBIG_OFFBIG_LDFLAGS		33
-#define	_CS_XBS5_LPBIG_OFFBIG_LIBS		34
-#define	_CS_XBS5_LPBIG_OFFBIG_LINTFLAGS		35
-#endif
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#define	_CS_DARWIN_USER_DIR			65536
-#define	_CS_DARWIN_USER_TEMP_DIR		65537
-#define	_CS_DARWIN_USER_CACHE_DIR		65538
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-
-#ifdef _DARWIN_UNLIMITED_GETGROUPS
-#if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_3_2
-#error "_DARWIN_UNLIMITED_GETGROUPS specified, but -miphoneos-version-min version does not support it."
-#elif defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_6
-#error "_DARWIN_UNLIMITED_GETGROUPS specified, but -mmacosx-version-min version does not support it."
-#endif
-#endif
-
-/* POSIX.1-1990 */
-
-__BEGIN_DECLS
-void	 _exit(int) __dead2;
-int	 access(const char *, int);
-unsigned int
-	 alarm(unsigned int);
-int	 chdir(const char *);
-int	 chown(const char *, uid_t, gid_t);
-
-int	 close(int) __DARWIN_ALIAS_C(close);
-
-int	 dup(int);
-int	 dup2(int, int);
-int	 execl(const char * __path, const char * __arg0, ...) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-int	 execle(const char * __path, const char * __arg0, ...) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-int	 execlp(const char * __file, const char * __arg0, ...) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-int	 execv(const char * __path, char * const * __argv) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-int	 execve(const char * __file, char * const * __argv, char * const * __envp) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-int	 execvp(const char * __file, char * const * __argv) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-pid_t	 fork(void) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-long	 fpathconf(int, int);
-char	*getcwd(char *, size_t);
-gid_t	 getegid(void);
-uid_t	 geteuid(void);
-gid_t	 getgid(void);
-#if defined(_DARWIN_UNLIMITED_GETGROUPS) || defined(_DARWIN_C_SOURCE)
-int	 getgroups(int, gid_t []) __DARWIN_ALIAS_STARTING(__MAC_10_6, __IPHONE_3_2, __DARWIN_EXTSN(getgroups));
-#else /* !_DARWIN_UNLIMITED_GETGROUPS && !_DARWIN_C_SOURCE */
-int	 getgroups(int, gid_t []);
-#endif /* _DARWIN_UNLIMITED_GETGROUPS || _DARWIN_C_SOURCE */
-char	*getlogin(void);
-pid_t	 getpgrp(void);
-pid_t	 getpid(void);
-pid_t	 getppid(void);
-uid_t	 getuid(void);
-int	 isatty(int);
-int	 link(const char *, const char *);
-off_t	 lseek(int, off_t, int);
-long	 pathconf(const char *, int);
-
-int	 pause(void) __DARWIN_ALIAS_C(pause);
-
-int	 pipe(int [2]);
-
-ssize_t	 read(int, void *, size_t) __DARWIN_ALIAS_C(read);
-
-int	 rmdir(const char *);
-int	 setgid(gid_t);
-int	 setpgid(pid_t, pid_t);
-pid_t	 setsid(void);
-int	 setuid(uid_t);
-
-unsigned int
-	 sleep(unsigned int) __DARWIN_ALIAS_C(sleep);
-
-long	 sysconf(int);
-pid_t	 tcgetpgrp(int);
-int	 tcsetpgrp(int, pid_t);
-char	*ttyname(int);
-
-#if __DARWIN_UNIX03
-int	 ttyname_r(int, char *, size_t) __DARWIN_ALIAS(ttyname_r);
-#else /* !__DARWIN_UNIX03 */
-char	*ttyname_r(int, char *, size_t);
-#endif /* __DARWIN_UNIX03 */
-
-int	 unlink(const char *);
-
-ssize_t	 write(int __fd, const void * __buf, size_t __nbyte) __DARWIN_ALIAS_C(write);
-__END_DECLS
-
-
-
-/* Additional functionality provided by:
- * POSIX.2-1992 C Language Binding Option
- */
-
-#if __DARWIN_C_LEVEL >= 199209L
-__BEGIN_DECLS
-size_t	 confstr(int, char *, size_t) __DARWIN_ALIAS(confstr);
-
-int	 getopt(int, char * const [], const char *) __DARWIN_ALIAS(getopt);
-
-extern char *optarg;			/* getopt(3) external variables */
-extern int optind, opterr, optopt;
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 199209L */
-
-
-
-/* Additional functionality provided by:
- * POSIX.1c-1995,
- * POSIX.1i-1995,
- * and the omnibus ISO/IEC 9945-1: 1996
- */
-
-#if __DARWIN_C_LEVEL >= 199506L
-#include <_ctermid.h>
-                               /* These F_* are really XSI or Issue 6 */
-#define F_ULOCK         0      /* unlock locked section */
-#define	F_LOCK          1      /* lock a section for exclusive use */
-#define	F_TLOCK         2      /* test and lock a section for exclusive use */
-#define	F_TEST          3      /* test a section for locks by other procs */
-
- __BEGIN_DECLS
-
-/* Begin XSI */
-/* Removed in Issue 6 */
-#if !defined(_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 200112L
-#if !defined(_POSIX_C_SOURCE)
-__deprecated __WATCHOS_PROHIBITED __TVOS_PROHIBITED
-#endif
-void	*brk(const void *);
-int	 chroot(const char *) __POSIX_C_DEPRECATED(199506L);
-#endif
-
-char	*crypt(const char *, const char *);
-#if __DARWIN_UNIX03
-void	 encrypt(char *, int) __DARWIN_ALIAS(encrypt);
-#else /* !__DARWIN_UNIX03 */
-int	 encrypt(char *, int);
-#endif /* __DARWIN_UNIX03 */
-int	 fchdir(int);
-long	 gethostid(void);
-pid_t	 getpgid(pid_t);
-pid_t	 getsid(pid_t);
-
-/* Removed in Issue 6 */
-#if !defined(_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 200112L
-int	 getdtablesize(void) __POSIX_C_DEPRECATED(199506L);
-int	 getpagesize(void) __pure2 __POSIX_C_DEPRECATED(199506L);
-char	*getpass(const char *) __POSIX_C_DEPRECATED(199506L);
-#endif
-
-/* Removed in Issue 7 */
-#if !defined(_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 200809L
-char	*getwd(char *) __POSIX_C_DEPRECATED(200112L); /* obsoleted by getcwd() */
-#endif
-
-int	 lchown(const char *, uid_t, gid_t) __DARWIN_ALIAS(lchown);
-
-int	 lockf(int, int, off_t) __DARWIN_ALIAS_C(lockf);
-
-int	 nice(int) __DARWIN_ALIAS(nice);
-
-ssize_t	 pread(int __fd, void * __buf, size_t __nbyte, off_t __offset) __DARWIN_ALIAS_C(pread);
-
-ssize_t	 pwrite(int __fd, const void * __buf, size_t __nbyte, off_t __offset) __DARWIN_ALIAS_C(pwrite);
-
-/* Removed in Issue 6 */
-#if !defined(_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 200112L
-/* Note that Issue 5 changed the argument as intprt_t,
- * but we keep it as int for binary compatability. */
-#if !defined(_POSIX_C_SOURCE)
-__deprecated __WATCHOS_PROHIBITED __TVOS_PROHIBITED
-#endif
-void	*sbrk(int);
-#endif
-
-#if __DARWIN_UNIX03
-pid_t	 setpgrp(void) __DARWIN_ALIAS(setpgrp);
-#else /* !__DARWIN_UNIX03 */
-int	 setpgrp(pid_t pid, pid_t pgrp);	/* obsoleted by setpgid() */
-#endif /* __DARWIN_UNIX03 */
-
-int	 setregid(gid_t, gid_t) __DARWIN_ALIAS(setregid);
-
-int	 setreuid(uid_t, uid_t) __DARWIN_ALIAS(setreuid);
-
-void     swab(const void * __restrict, void * __restrict, ssize_t);
-void	 sync(void);
-int	 truncate(const char *, off_t);
-useconds_t	 ualarm(useconds_t, useconds_t);
-int	 usleep(useconds_t) __DARWIN_ALIAS_C(usleep);
-pid_t	 vfork(void) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-/* End XSI */
-
-int	 fsync(int) __DARWIN_ALIAS_C(fsync);
-
-int	 ftruncate(int, off_t);
-int	 getlogin_r(char *, size_t);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 199506L */
-
-
-
-/* Additional functionality provided by:
- * POSIX.1-2001
- * ISO C99
- */
-
-#if __DARWIN_C_LEVEL >= 200112L
-__BEGIN_DECLS
-int	 fchown(int, uid_t, gid_t);
-int	 gethostname(char *, size_t);
-ssize_t  readlink(const char * __restrict, char * __restrict, size_t);
-int	 setegid(gid_t);
-int	 seteuid(uid_t);
-int	 symlink(const char *, const char *);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 200112L */
-
-
-
-/* Darwin extensions */
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-#include <sys/select.h>
-
-#include <sys/_types/_dev_t.h>
-#include <sys/_types/_mode_t.h>
-#include <sys/_types/_uuid_t.h>
-
-__BEGIN_DECLS
-void	 _Exit(int) __dead2;
-int	 accessx_np(const struct accessx_descriptor *, size_t, int *, uid_t);
-int	 acct(const char *);
-int	 add_profil(char *, size_t, unsigned long, unsigned int) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-void	 endusershell(void);
-int	 execvP(const char * __file, const char * __searchpath, char * const * __argv)  __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-char	*fflagstostr(unsigned long);
-int	 getdomainname(char *, int);
-int	 getgrouplist(const char *, int, int *, int *);
-#if defined(__has_include)
-#if __has_include(<gethostuuid_private.h>)
-#include <gethostuuid_private.h>
-#else
-#include <gethostuuid.h>
-#endif
-#else
-#include <gethostuuid.h>
-#endif
-mode_t	 getmode(const void *, mode_t);
-int	 getpeereid(int, uid_t *, gid_t *);
-int	 getsgroups_np(int *, uuid_t);
-char	*getusershell(void);
-int	 getwgroups_np(int *, uuid_t);
-int	 initgroups(const char *, int);
-int	 issetugid(void);
-char	*mkdtemp(char *);
-int	 mknod(const char *, mode_t, dev_t);
-int	 mkpath_np(const char *path, mode_t omode) __OSX_AVAILABLE_STARTING(__MAC_10_8, __IPHONE_5_0); /* returns errno */
-int	 mkpathat_np(int dfd, const char *path, mode_t omode) /* returns errno */
-		__OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0)
-		__TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0);
-int	 mkstemp(char *);
-int	 mkstemps(char *, int);
-char	*mktemp(char *);
-int	 mkostemp(char *path, int oflags)
-		__OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0)
-		__TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0);
-int	 mkostemps(char *path, int slen, int oflags)
-		__OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0)
-		__TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0);
-/* Non-portable mkstemp that uses open_dprotected_np */
-int	 mkstemp_dprotected_np(char *path, int dpclass, int dpflags)
-		__OSX_UNAVAILABLE __IOS_AVAILABLE(10.0)
-		__TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0);
-char   *mkdtempat_np(int dfd, char *path)
-		__OSX_AVAILABLE(10.13) __IOS_AVAILABLE(11.0)
-		__TVOS_AVAILABLE(11.0) __WATCHOS_AVAILABLE(4.0);
-int     mkstempsat_np(int dfd, char *path, int slen)
-		__OSX_AVAILABLE(10.13) __IOS_AVAILABLE(11.0)
-		__TVOS_AVAILABLE(11.0) __WATCHOS_AVAILABLE(4.0);
-int     mkostempsat_np(int dfd, char *path, int slen, int oflags)
-		__OSX_AVAILABLE(10.13) __IOS_AVAILABLE(11.0)
-		__TVOS_AVAILABLE(11.0) __WATCHOS_AVAILABLE(4.0);
-int	 nfssvc(int, void *);
-int	 profil(char *, size_t, unsigned long, unsigned int);
-
-__deprecated_msg("Use of per-thread security contexts is error-prone and discouraged.")
-int	 pthread_setugid_np(uid_t, gid_t);
-int	 pthread_getugid_np( uid_t *, gid_t *);
-
-int	 reboot(int);
-int	 revoke(const char *);
-
-__deprecated int	 rcmd(char **, int, const char *, const char *, const char *, int *);
-__deprecated int	 rcmd_af(char **, int, const char *, const char *, const char *, int *,
-		int);
-__deprecated int	 rresvport(int *);
-__deprecated int	 rresvport_af(int *, int);
-__deprecated int	 iruserok(unsigned long, int, const char *, const char *);
-__deprecated int	 iruserok_sa(const void *, int, int, const char *, const char *);
-__deprecated int	 ruserok(const char *, int, const char *, const char *);
-
-int	 setdomainname(const char *, int);
-int	 setgroups(int, const gid_t *);
-void	 sethostid(long);
-int	 sethostname(const char *, int);
-#if __DARWIN_UNIX03
-void	 setkey(const char *) __DARWIN_ALIAS(setkey);
-#else /* !__DARWIN_UNIX03 */
-int	 setkey(const char *);
-#endif /* __DARWIN_UNIX03 */
-int	 setlogin(const char *);
-void	*setmode(const char *) __DARWIN_ALIAS_STARTING(__MAC_10_6, __IPHONE_2_0, __DARWIN_ALIAS(setmode));
-int	 setrgid(gid_t);
-int	 setruid(uid_t);
-int	 setsgroups_np(int, const uuid_t);
-void	 setusershell(void);
-int	 setwgroups_np(int, const uuid_t);
-int	 strtofflags(char **, unsigned long *, unsigned long *);
-int	 swapon(const char *);
-int	 ttyslot(void);
-int	 undelete(const char *);
-int	 unwhiteout(const char *);
-void	*valloc(size_t);			
-
-__WATCHOS_PROHIBITED __TVOS_PROHIBITED
-__OS_AVAILABILITY_MSG(ios,deprecated=10.0,"syscall(2) is unsupported; "
-    "please switch to a supported interface. For SYS_kdebug_trace use kdebug_signpost().")
-__OS_AVAILABILITY_MSG(macosx,deprecated=10.12,"syscall(2) is unsupported; "
-    "please switch to a supported interface. For SYS_kdebug_trace use kdebug_signpost().")
-int	 syscall(int, ...);
-
-extern char *suboptarg;			/* getsubopt(3) external variable */
-int	 getsubopt(char **, char * const *, char **);
-
-/*  HFS & HFS Plus semantics system calls go here */
-#ifdef __LP64__
-int    fgetattrlist(int,void*,void*,size_t,unsigned int) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_0);
-int    fsetattrlist(int,void*,void*,size_t,unsigned int) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_0);
-int    getattrlist(const char*,void*,void*,size_t,unsigned int) __DARWIN_ALIAS(getattrlist);
-int    setattrlist(const char*,void*,void*,size_t,unsigned int) __DARWIN_ALIAS(setattrlist);
-int exchangedata(const char*,const char*,unsigned int) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-int    getdirentriesattr(int,void*,void*,size_t,unsigned int*,unsigned int*,unsigned int*,unsigned int) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-
-#else /* __LP64__ */
-int	fgetattrlist(int,void*,void*,size_t,unsigned long) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_0);
-int	fsetattrlist(int,void*,void*,size_t,unsigned long) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_0);
-int	getattrlist(const char*,void*,void*,size_t,unsigned long) __DARWIN_ALIAS(getattrlist);
-int	setattrlist(const char*,void*,void*,size_t,unsigned long) __DARWIN_ALIAS(setattrlist);
-int exchangedata(const char*,const char*,unsigned long)
-		__OSX_DEPRECATED(10.0, 10.13, "use renamex_np with the RENAME_SWAP flag")
-		__IOS_DEPRECATED(2.0, 11.0, "use renamex_np with the RENAME_SWAP flag")
-		__WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-int	getdirentriesattr(int,void*,void*,size_t,unsigned long*,unsigned long*,unsigned long*,unsigned long) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-
-#endif /* __LP64__ */
-
-struct fssearchblock;
-struct searchstate;
-
-int	 searchfs(const char *, struct fssearchblock *, unsigned long *, unsigned int, unsigned int, struct searchstate *) __WATCHOS_PROHIBITED __TVOS_PROHIBITED;
-int	 fsctl(const char *,unsigned long,void*,unsigned int);
-int	 ffsctl(int,unsigned long,void*,unsigned int) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_0);
-
-#define	SYNC_VOLUME_FULLSYNC	0x01	/* Flush data and metadata to platter, not just to disk cache */
-#define SYNC_VOLUME_WAIT	0x02	/* Wait for sync to complete */
-
-int	fsync_volume_np(int, int) __OSX_AVAILABLE_STARTING(__MAC_10_8, __IPHONE_6_0);
-int	sync_volume_np(const char *, int) __OSX_AVAILABLE_STARTING(__MAC_10_8, __IPHONE_6_0);
-
-extern int optreset;
-
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-#endif /* _UNISTD_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/uuid/uuid.h b/lib/libc/include/x86_64-macos.10-none/uuid/uuid.h
deleted file mode 100644
index ce75c9e0e1..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/uuid/uuid.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * Public include file for the UUID library
- *
- * Copyright (C) 1996, 1997, 1998 Theodore Ts'o.
- *
- * %Begin-Header%
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, and the entire permission notice in its entirety,
- *    including the disclaimer of warranties.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote
- *    products derived from this software without specific prior
- *    written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ALL OF
- * WHICH ARE HEREBY DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
- * USE OF THIS SOFTWARE, EVEN IF NOT ADVISED OF THE POSSIBILITY OF SUCH
- * DAMAGE.
- * %End-Header%
- */
-
-#ifndef _UUID_UUID_H
-#define _UUID_UUID_H
-
-#include <sys/_types.h>
-#include <sys/_types/_uuid_t.h>
-
-#ifndef _UUID_STRING_T
-#define _UUID_STRING_T
-typedef __darwin_uuid_string_t  uuid_string_t;
-#endif /* _UUID_STRING_T */
-
-#define UUID_DEFINE(name, u0, u1, u2, u3, u4, u5, u6, u7, u8, u9, u10, u11, u12, u13, u14, u15) \
-	static const uuid_t name __attribute__ ((unused)) = {u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,u10,u11,u12,u13,u14,u15}
-
-UUID_DEFINE(UUID_NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void uuid_clear(uuid_t uu);
-
-int uuid_compare(const uuid_t uu1, const uuid_t uu2);
-
-void uuid_copy(uuid_t dst, const uuid_t src);
-
-void uuid_generate(uuid_t out);
-void uuid_generate_random(uuid_t out);
-void uuid_generate_time(uuid_t out);
-
-void uuid_generate_early_random(uuid_t out);
-
-int uuid_is_null(const uuid_t uu);
-
-int uuid_parse(const uuid_string_t in, uuid_t uu);
-
-void uuid_unparse(const uuid_t uu, uuid_string_t out);
-void uuid_unparse_lower(const uuid_t uu, uuid_string_t out);
-void uuid_unparse_upper(const uuid_t uu, uuid_string_t out);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _UUID_UUID_H */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/xlocale/_inttypes.h b/lib/libc/include/x86_64-macos.10-none/xlocale/_inttypes.h
deleted file mode 100644
index 4da8f90c6d..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/xlocale/_inttypes.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2005 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _XLOCALE__INTTYPES_H_
-#define _XLOCALE__INTTYPES_H_
-
-#include <sys/cdefs.h>
-#include <stdint.h>
-#include <_xlocale.h>
-
-__BEGIN_DECLS
-intmax_t  strtoimax_l(const char * __restrict nptr, char ** __restrict endptr,
-		int base, locale_t);
-uintmax_t strtoumax_l(const char * __restrict nptr, char ** __restrict endptr,
-		int base, locale_t);
-intmax_t  wcstoimax_l(const wchar_t * __restrict nptr,
-		wchar_t ** __restrict endptr, int base, locale_t);
-uintmax_t wcstoumax_l(const wchar_t * __restrict nptr,
-		wchar_t ** __restrict endptr, int base, locale_t);
-
-/* Poison the following routines if -fshort-wchar is set */
-#if !defined(__cplusplus) && defined(__WCHAR_MAX__) && __WCHAR_MAX__ <= 0xffffU
-#pragma GCC poison wcstoimax_l wcstoumax_l
-#endif
-__END_DECLS
-
-#endif /* _XLOCALE__INTTYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/xlocale/_wchar.h b/lib/libc/include/x86_64-macos.10-none/xlocale/_wchar.h
deleted file mode 100644
index b4af0f816e..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/xlocale/_wchar.h
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * Copyright (c) 2005 Apple Computer, Inc. All rights reserved.
- *
- * @APPLE_LICENSE_HEADER_START@
- * 
- * This file contains Original Code and/or Modifications of Original Code
- * as defined in and that are subject to the Apple Public Source License
- * Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
- * 
- * The Original Code and all software distributed under the License are
- * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
- * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
- * Please see the License for the specific language governing rights and
- * limitations under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
- */
-
-#ifndef _XLOCALE__WCHAR_H_
-#define _XLOCALE__WCHAR_H_
-
-#include <_stdio.h>
-#include <_xlocale.h>
-#include <sys/_types/_mbstate_t.h>
-
-/* Initially added in Issue 4 */
-__BEGIN_DECLS
-wint_t	btowc_l(int, locale_t);
-wint_t	fgetwc_l(FILE *, locale_t);
-wchar_t	*fgetws_l(wchar_t * __restrict, int, FILE * __restrict, locale_t);
-wint_t	fputwc_l(wchar_t, FILE *, locale_t);
-int	fputws_l(const wchar_t * __restrict, FILE * __restrict, locale_t);
-int	fwprintf_l(FILE * __restrict, locale_t, const wchar_t * __restrict, ...);
-int	fwscanf_l(FILE * __restrict, locale_t, const wchar_t * __restrict, ...);
-wint_t	getwc_l(FILE *, locale_t);
-wint_t	getwchar_l(locale_t);
-size_t	mbrlen_l(const char * __restrict, size_t, mbstate_t * __restrict,
-	    locale_t);
-size_t	mbrtowc_l(wchar_t * __restrict, const char * __restrict, size_t,
-	    mbstate_t * __restrict, locale_t);
-int	mbsinit_l(const mbstate_t *, locale_t);
-size_t	mbsrtowcs_l(wchar_t * __restrict, const char ** __restrict, size_t,
-	    mbstate_t * __restrict, locale_t);
-wint_t	putwc_l(wchar_t, FILE *, locale_t);
-wint_t	putwchar_l(wchar_t, locale_t);
-int	swprintf_l(wchar_t * __restrict, size_t n, locale_t,
-		const wchar_t * __restrict, ...);
-int	swscanf_l(const wchar_t * __restrict, locale_t,
-		const wchar_t * __restrict, ...);
-wint_t	ungetwc_l(wint_t, FILE *, locale_t);
-int	vfwprintf_l(FILE * __restrict, locale_t, const wchar_t * __restrict,
-		__darwin_va_list);
-int	vswprintf_l(wchar_t * __restrict, size_t n, locale_t,
-		const wchar_t * __restrict, __darwin_va_list);
-int	vwprintf_l(locale_t, const wchar_t * __restrict, __darwin_va_list);
-size_t	wcrtomb_l(char * __restrict, wchar_t, mbstate_t * __restrict,
-	    locale_t);
-int	wcscoll_l(const wchar_t *, const wchar_t *, locale_t);
-size_t	wcsftime_l(wchar_t * __restrict, size_t, const wchar_t * __restrict,
-		const struct tm * __restrict, locale_t)
-		__DARWIN_ALIAS(wcsftime_l);
-size_t	wcsrtombs_l(char * __restrict, const wchar_t ** __restrict, size_t,
-	    mbstate_t * __restrict, locale_t);
-double	wcstod_l(const wchar_t * __restrict, wchar_t ** __restrict, locale_t);
-long	wcstol_l(const wchar_t * __restrict, wchar_t ** __restrict, int,
-	    locale_t);
-unsigned long
-	wcstoul_l(const wchar_t * __restrict, wchar_t ** __restrict, int,
-	    locale_t);
-int	wcswidth_l(const wchar_t *, size_t, locale_t);
-size_t	wcsxfrm_l(wchar_t * __restrict, const wchar_t * __restrict, size_t,
-	    locale_t);
-int	wctob_l(wint_t, locale_t);
-int	wcwidth_l(wchar_t, locale_t);
-int	wprintf_l(locale_t, const wchar_t * __restrict, ...);
-int	wscanf_l(locale_t, const wchar_t * __restrict, ...);
-__END_DECLS
- 
- 
- 
-/* Additional functionality provided by:
- * POSIX.1-2001
- */
-
-#if __DARWIN_C_LEVEL >= 200112L
-__BEGIN_DECLS
-int	vfwscanf_l(FILE * __restrict, locale_t, const wchar_t * __restrict,
-		__darwin_va_list);
-int	vswscanf_l(const wchar_t * __restrict, locale_t,
-		const wchar_t * __restrict, __darwin_va_list);
-int	vwscanf_l(locale_t, const wchar_t * __restrict, __darwin_va_list);
-float	wcstof_l(const wchar_t * __restrict, wchar_t ** __restrict, locale_t);
-long double
-	wcstold_l(const wchar_t * __restrict, wchar_t ** __restrict, locale_t);
-#if !__DARWIN_NO_LONG_LONG
-long long
-	wcstoll_l(const wchar_t * __restrict, wchar_t ** __restrict, int,
-	    locale_t);
-unsigned long long
-	wcstoull_l(const wchar_t * __restrict, wchar_t ** __restrict, int,
-	    locale_t);
-#endif /* !__DARWIN_NO_LONG_LONG */
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 200112L */
-
-
-
-/* Additional functionality provided by:
- * POSIX.1-2008
- */
-
-#if __DARWIN_C_LEVEL >= 200809L
-__BEGIN_DECLS
-size_t	mbsnrtowcs_l(wchar_t * __restrict, const char ** __restrict, size_t,
-	    size_t, mbstate_t * __restrict, locale_t);
-int     wcscasecmp_l(const wchar_t *, const wchar_t *, locale_t) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-int     wcsncasecmp_l(const wchar_t *, const wchar_t *, size_t n, locale_t) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-size_t	wcsnrtombs_l(char * __restrict, const wchar_t ** __restrict, size_t,
-	    size_t, mbstate_t * __restrict, locale_t);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= 200809L */
-
-
-
-/* Darwin extensions */
-
-#if __DARWIN_C_LEVEL >= __DARWIN_C_FULL
-__BEGIN_DECLS
-wchar_t	*fgetwln_l(FILE * __restrict, size_t *, locale_t) __OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
-__END_DECLS
-#endif /* __DARWIN_C_LEVEL >= __DARWIN_C_FULL */
-
-
-
-/* Poison the following routines if -fshort-wchar is set */
-#if !defined(__cplusplus) && defined(__WCHAR_MAX__) && __WCHAR_MAX__ <= 0xffffU
-#pragma GCC poison fgetwln_l fgetws_l fputwc_l fputws_l fwprintf_l fwscanf_l mbrtowc_l mbsnrtowcs_l mbsrtowcs_l putwc_l putwchar_l swprintf_l swscanf_l vfwprintf_l vfwscanf_l vswprintf_l vswscanf_l vwprintf_l vwscanf_l wcrtomb_l wcscoll_l wcsftime_l wcsftime_l wcsnrtombs_l wcsrtombs_l wcstod_l wcstof_l wcstol_l wcstold_l wcstoll_l wcstoul_l wcstoull_l wcswidth_l wcsxfrm_l wcwidth_l wprintf_l wscanf_l
-#endif
-
-#endif /* _XLOCALE__WCHAR_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/xpc/activity.h b/lib/libc/include/x86_64-macos.10-none/xpc/activity.h
deleted file mode 100644
index c48051f145..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/xpc/activity.h
+++ /dev/null
@@ -1,446 +0,0 @@
-#ifndef __XPC_ACTIVITY_H__
-#define __XPC_ACTIVITY_H__
-
-#ifndef __XPC_INDIRECT__
-#error "Please #include <xpc/xpc.h> instead of this file directly."
-// For HeaderDoc.
-#include <xpc/base.h>
-#endif // __XPC_INDIRECT__ 
-
-#ifdef __BLOCKS__
-
-XPC_ASSUME_NONNULL_BEGIN
-__BEGIN_DECLS
-
-/*
- * The following are a collection of keys and values used to set an activity's
- * execution criteria.
- */
-
-/*!
- * @constant XPC_ACTIVITY_INTERVAL
- * An integer property indicating the desired time interval (in seconds) of the 
- * activity. The activity will not be run more than once per time interval.
- * Due to the nature of XPC Activity finding an opportune time to run
- * the activity, any two occurrences may be more or less than 'interval'
- * seconds apart, but on average will be 'interval' seconds apart.
- * The presence of this key implies the following, unless overridden:
- * - XPC_ACTIVITY_REPEATING with a value of true
- * - XPC_ACTIVITY_DELAY with a value of half the 'interval'
- *   The delay enforces a minimum distance between any two occurrences.
- * - XPC_ACTIVITY_GRACE_PERIOD with a value of half the 'interval'.
- *   The grace period is the amount of time allowed to pass after the end of
- *   the interval before more aggressive scheduling occurs. The grace period
- *   does not increase the size of the interval.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const char * const XPC_ACTIVITY_INTERVAL;
-
-/*!
- * @constant XPC_ACTIVITY_REPEATING
- * A boolean property indicating whether this is a repeating activity.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const char * const XPC_ACTIVITY_REPEATING;
-
-/*!
- * @constant XPC_ACTIVITY_DELAY
- * An integer property indicating the number of seconds to delay before
- * beginning the activity.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const char * const XPC_ACTIVITY_DELAY;
-
-/*!
- * @constant XPC_ACTIVITY_GRACE_PERIOD
- * An integer property indicating the number of seconds to allow as a grace
- * period before the scheduling of the activity becomes more aggressive.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const char * const XPC_ACTIVITY_GRACE_PERIOD;
-
-
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const int64_t XPC_ACTIVITY_INTERVAL_1_MIN;
-
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const int64_t XPC_ACTIVITY_INTERVAL_5_MIN;
-
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const int64_t XPC_ACTIVITY_INTERVAL_15_MIN;
-
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const int64_t XPC_ACTIVITY_INTERVAL_30_MIN;
-
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const int64_t XPC_ACTIVITY_INTERVAL_1_HOUR;
-
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const int64_t XPC_ACTIVITY_INTERVAL_4_HOURS;
-
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const int64_t XPC_ACTIVITY_INTERVAL_8_HOURS;
-
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const int64_t XPC_ACTIVITY_INTERVAL_1_DAY;
-
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const int64_t XPC_ACTIVITY_INTERVAL_7_DAYS;
-
-/*!
- * @constant XPC_ACTIVITY_PRIORITY
- * A string property indicating the priority of the activity.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const char * const XPC_ACTIVITY_PRIORITY;
-
-/*!
- * @constant XPC_ACTIVITY_PRIORITY_MAINTENANCE
- * A string indicating activity is maintenance priority.
- *
- * Maintenance priority is intended for user-invisible maintenance tasks
- * such as garbage collection or optimization.
- *
- * Maintenance activities are not permitted to run if the device thermal
- * condition exceeds a nominal level or if the battery level is lower than 20%.
- * In Low Power Mode (on supported devices), maintenance activities are not
- * permitted to run while the device is on battery, or plugged in and the
- * battery level is lower than 30%.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const char * const XPC_ACTIVITY_PRIORITY_MAINTENANCE;
-
-/*!
- * @constant XPC_ACTIVITY_PRIORITY_UTILITY
- * A string indicating activity is utility priority.
- *
- * Utility priority is intended for user-visible tasks such as fetching data
- * from the network, copying files, or importing data.
- *
- * Utility activities are not permitted to run if the device thermal condition
- * exceeds a moderate level or if the battery level is less than 10%.  In Low
- * Power Mode (on supported devices) when on battery power, utility activities
- * are only permitted when they are close to their deadline (90% of their time
- * window has elapsed).
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const char * const XPC_ACTIVITY_PRIORITY_UTILITY;
-
-/*!
- * @constant XPC_ACTIVITY_ALLOW_BATTERY
- * A Boolean value indicating whether the activity should be allowed to run
- * while the computer is on battery power. The default value is false for
- * maintenance priority activity and true for utility priority activity.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const char * const XPC_ACTIVITY_ALLOW_BATTERY;
-
-/*!
- * @constant XPC_ACTIVITY_REQUIRE_SCREEN_SLEEP
- * A Boolean value indicating whether the activity should only be performed
- * while device appears to be asleep.  Note that the definition of screen sleep
- * may vary by platform and may include states where the device is known to be
- * idle despite the fact that the display itself is still powered.  Defaults to
- * false.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const char * const XPC_ACTIVITY_REQUIRE_SCREEN_SLEEP; // bool
-
-/*!
- * @constant XPC_ACTIVITY_REQUIRE_BATTERY_LEVEL
- * An integer percentage of minimum battery charge required to allow the
- * activity to run. A default minimum battery level is determined by the
- * system.
- */
-__OSX_AVAILABLE_BUT_DEPRECATED_MSG(__MAC_10_9, __MAC_10_9, __IPHONE_7_0, __IPHONE_7_0,
-	"REQUIRE_BATTERY_LEVEL is not implemented")
-XPC_EXPORT
-const char * const XPC_ACTIVITY_REQUIRE_BATTERY_LEVEL; // int (%)
-
-/*!
- * @constant XPC_ACTIVITY_REQUIRE_HDD_SPINNING
- * A Boolean value indicating whether the activity should only be performed
- * while the hard disk drive (HDD) is spinning. Computers with flash storage
- * are considered to be equivalent to HDD spinning. Defaults to false.
- */
-__OSX_AVAILABLE_BUT_DEPRECATED_MSG(__MAC_10_9, __MAC_10_9, __IPHONE_7_0, __IPHONE_7_0,
-	"REQUIRE_HDD_SPINNING is not implemented")
-XPC_EXPORT
-const char * const XPC_ACTIVITY_REQUIRE_HDD_SPINNING; // bool
-
-/*!
- * @define XPC_TYPE_ACTIVITY
- * A type representing the XPC activity object.
- */
-#define XPC_TYPE_ACTIVITY (&_xpc_type_activity)
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-XPC_TYPE(_xpc_type_activity);
-
-/*!
- * @typedef xpc_activity_t
- *
- * @abstract
- * An XPC activity object.
- *
- * @discussion
- * This object represents a set of execution criteria and a current execution
- * state for background activity on the system. Once an activity is registered,
- * the system will evaluate its criteria to determine whether the activity is
- * eligible to run under current system conditions. When an activity becomes
- * eligible to run, its execution state will be updated and an invocation of
- * its handler block will be made.
- */
-XPC_DECL(xpc_activity);
-
-/*!
- * @typedef xpc_activity_handler_t
- *
- * @abstract
- * A block that is called when an XPC activity becomes eligible to run.
- */
-XPC_NONNULL1
-typedef void (^xpc_activity_handler_t)(xpc_activity_t activity);
-
-/*!
- * @constant XPC_ACTIVITY_CHECK_IN
- * This constant may be passed to xpc_activity_register() as the criteria
- * dictionary in order to check in with the system for previously registered
- * activity using the same identifier (for example, an activity taken from a
- * launchd property list).
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT
-const xpc_object_t XPC_ACTIVITY_CHECK_IN;
-
-/*!
- * @function xpc_activity_register
- *
- * @abstract
- * Registers an activity with the system.
- *
- * @discussion
- * Registers a new activity with the system. The criteria of the activity are
- * described by the dictionary passed to this function. If an activity with the
- * same identifier already exists, the criteria provided override the existing
- * criteria unless the special dictionary XPC_ACTIVITY_CHECK_IN is used. The
- * XPC_ACTIVITY_CHECK_IN dictionary instructs the system to first look up an
- * existing activity without modifying its criteria. Once the existing activity
- * is found (or a new one is created with an empty set of criteria) the handler
- * will be called with an activity object in the XPC_ACTIVITY_STATE_CHECK_IN
- * state.
- *
- * @param identifier
- * A unique identifier for the activity. Each application has its own namespace.
- * The identifier should remain constant across registrations, relaunches of
- * the application, and reboots. It should identify the kind of work being done,
- * not a particular invocation of the work.
- *
- * @param criteria
- * A dictionary of criteria for the activity.
- *
- * @param handler
- * The handler block to be called when the activity changes state to one of the
- * following states:
- * - XPC_ACTIVITY_STATE_CHECK_IN (optional)
- * - XPC_ACTIVITY_STATE_RUN
- *
- * The handler block is never invoked reentrantly. It will be invoked on a
- * dispatch queue with an appropriate priority to perform the activity.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2 XPC_NONNULL3
-void
-xpc_activity_register(const char *identifier, xpc_object_t criteria,
-	xpc_activity_handler_t handler);
-
-/*!
- * @function xpc_activity_copy_criteria
- *
- * @abstract
- * Returns an XPC dictionary describing the execution criteria of an activity.
- * This will return NULL in cases where the activity has already completed, e.g.
- * when checking in to an event that finished and was not rescheduled.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_RETURNS_RETAINED XPC_NONNULL1
-xpc_object_t _Nullable
-xpc_activity_copy_criteria(xpc_activity_t activity);
-
-/*!
- * @function xpc_activity_set_criteria
- *
- * @abstract
- * Modifies the execution criteria of an activity.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT XPC_NONNULL1 XPC_NONNULL2
-void
-xpc_activity_set_criteria(xpc_activity_t activity, xpc_object_t criteria);
-
-/*!
- * @enum xpc_activity_state_t
- * An activity is defined to be in one of the following states. Applications
- * may check the current state of the activity using xpc_activity_get_state()
- * in the handler block provided to xpc_activity_register().
- *
- * The application can modify the state of the activity by calling
- * xpc_activity_set_state() with one of the following:
- * - XPC_ACTIVITY_STATE_DEFER
- * - XPC_ACTIVITY_STATE_CONTINUE
- * - XPC_ACTIVITY_STATE_DONE
- *
- * @constant XPC_ACTIVITY_STATE_CHECK_IN
- * An activity in this state has just completed a checkin with the system after
- * XPC_ACTIVITY_CHECK_IN was provided as the criteria dictionary to
- * xpc_activity_register. The state gives the application an opportunity to
- * inspect and modify the activity's criteria.
- *
- * @constant XPC_ACTIVITY_STATE_WAIT
- * An activity in this state is waiting for an opportunity to run. This value
- * is never returned within the activity's handler block, as the block is
- * invoked in response to XPC_ACTIVITY_STATE_CHECK_IN or XPC_ACTIVITY_STATE_RUN.
- *
- * Note:
- * A launchd job may idle exit while an activity is in the wait state and be
- * relaunched in response to the activity becoming runnable. The launchd job
- * simply needs to re-register for the activity on its next launch by passing
- * XPC_ACTIVITY_STATE_CHECK_IN to xpc_activity_register().
- *
- * @constant XPC_ACTIVITY_STATE_RUN
- * An activity in this state is eligible to run based on its criteria.
- *
- * @constant XPC_ACTIVITY_STATE_DEFER
- * An application may pass this value to xpc_activity_set_state() to indicate
- * that the activity should be deferred (placed back into the WAIT state) until
- * a time when its criteria are met again. Deferring an activity does not reset
- * any of its time-based criteria (in other words, it will remain past due).
- *
- * IMPORTANT:
- * This should be done in response to observing xpc_activity_should_defer().
- * It should not be done unilaterally. If you determine that conditions are bad
- * to do your activity's work for reasons you can't express in a criteria
- * dictionary, you should set the activity's state to XPC_ACTIVITY_STATE_DONE.
- *
- *
- * @constant XPC_ACTIVITY_STATE_CONTINUE
- * An application may pass this value to xpc_activity_set_state() to indicate
- * that the activity will continue its operation beyond the return of its
- * handler block. This can be used to extend an activity to include asynchronous
- * operations. The activity's handler block will not be invoked again until the
- * state has been updated to either XPC_ACTIVITY_STATE_DEFER or, in the case
- * of repeating activity, XPC_ACTIVITY_STATE_DONE.
- *
- * @constant XPC_ACTIVITY_STATE_DONE
- * An application may pass this value to xpc_activity_set_state() to indicate
- * that the activity has completed. For non-repeating activity, the resources
- * associated with the activity will be automatically released upon return from
- * the handler block. For repeating activity, timers present in the activity's
- * criteria will be reset.
- */
-enum {
-	XPC_ACTIVITY_STATE_CHECK_IN,
-	XPC_ACTIVITY_STATE_WAIT,
-	XPC_ACTIVITY_STATE_RUN,
-	XPC_ACTIVITY_STATE_DEFER,
-	XPC_ACTIVITY_STATE_CONTINUE,
-	XPC_ACTIVITY_STATE_DONE,
-};
-typedef long xpc_activity_state_t;
-
-/*!
- * @function xpc_activity_get_state
- *
- * @abstract
- * Returns the current state of an activity.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-xpc_activity_state_t
-xpc_activity_get_state(xpc_activity_t activity);
-
-/*!
- * @function xpc_activity_set_state
- *
- * @abstract
- * Updates the current state of an activity.
- *
- * @return
- * Returns true if the state was successfully updated; otherwise, returns
- * false if the requested state transition is not valid.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-bool
-xpc_activity_set_state(xpc_activity_t activity, xpc_activity_state_t state);
-
-/*!
- * @function xpc_activity_should_defer
- *
- * @abstract
- * Test whether an activity should be deferred.
- *
- * @discussion
- * This function may be used to test whether the criteria of a long-running
- * activity are still satisfied. If not, the system indicates that the
- * application should defer the activity. The application may acknowledge the
- * deferral by calling xpc_activity_set_state() with XPC_ACTIVITY_STATE_DEFER.
- * Once deferred, the system will place the activity back into the WAIT state
- * and re-invoke the handler block at the earliest opportunity when the criteria
- * are once again satisfied.
- *
- * @return
- * Returns true if the activity should be deferred.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT XPC_WARN_RESULT XPC_NONNULL1
-bool
-xpc_activity_should_defer(xpc_activity_t activity);
-
-/*!
- * @function xpc_activity_unregister
- *
- * @abstract
- * Unregisters an activity found by its identifier.
- *
- * @discussion
- * A dynamically registered activity will be deleted in response to this call.
- * Statically registered activity (from a launchd property list) will be
- * deleted until the job is next loaded (e.g. at next boot).
- *
- * Unregistering an activity has no effect on any outstanding xpc_activity_t
- * objects or any currently executing xpc_activity_handler_t blocks; however,
- * no new handler block invocations will be made after it is unregistered.
- *
- * @param identifier
- * The identifier of the activity to unregister.
- */
-__OSX_AVAILABLE_STARTING(__MAC_10_9, __IPHONE_7_0)
-XPC_EXPORT XPC_NONNULL1
-void
-xpc_activity_unregister(const char *identifier);
-
-__END_DECLS
-XPC_ASSUME_NONNULL_END
-
-#endif // __BLOCKS__
-
-#endif // __XPC_ACTIVITY_H__
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/xpc/availability.h b/lib/libc/include/x86_64-macos.10-none/xpc/availability.h
deleted file mode 100644
index d4efcec685..0000000000
--- a/lib/libc/include/x86_64-macos.10-none/xpc/availability.h
+++ /dev/null
@@ -1,120 +0,0 @@
-#ifndef __XPC_AVAILABILITY_H__
-#define __XPC_AVAILABILITY_H__
-
-#include <Availability.h>
-
-// Certain parts of the project use all the project's headers but have to build
-// against newer OSX SDKs than ebuild uses -- liblaunch_host being the example.
-// So we need to define these.
-#ifndef __MAC_10_15
-#define __MAC_10_15 101500
-#define __AVAILABILITY_INTERNAL__MAC_10_15 \
-__attribute__((availability(macosx, introduced=10.15)))
-#endif // __MAC_10_15
-
-#ifndef __MAC_10_14
-#define __MAC_10_14 101400
-#define __AVAILABILITY_INTERNAL__MAC_10_14 \
-__attribute__((availability(macosx, introduced=10.14)))
-#endif // __MAC_10_14
-
-#ifndef __MAC_10_13
-#define __MAC_10_13 101300
-#define __AVAILABILITY_INTERNAL__MAC_10_13 \
-	__attribute__((availability(macosx, introduced=10.13)))
-#endif // __MAC_10_13
-
-#ifndef __MAC_10_12
-#define __MAC_10_12 101200
-#define __AVAILABILITY_INTERNAL__MAC_10_12 \
-	__attribute__((availability(macosx, introduced=10.12)))
-#endif // __MAC_10_12
-
-#ifndef __MAC_10_11
-#define __MAC_10_11 101100
-#define __AVAILABILITY_INTERNAL__MAC_10_11 \
-	__attribute__((availability(macosx, introduced=10.11)))
-#endif // __MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_2_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_3_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_4_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_5_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_7_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_8_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_9_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_10_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_11_DEP__MAC_10_11
-#define __AVAILABILITY_INTERNAL__MAC_10_11_DEP__MAC_10_11
-#endif // __AVAILABILITY_INTERNAL__MAC_10_11_DEP__MAC_10_11
-
-#ifndef __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_13
-#define __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_13
-#endif // __AVAILABILITY_INTERNAL__MAC_10_6_DEP__MAC_10_13
-
-#if __has_include(<simulator_host.h>)
-#include <simulator_host.h>
-#else // __has_include(<simulator_host.h>)
-#ifndef IPHONE_SIMULATOR_HOST_MIN_VERSION_REQUIRED
-#define IPHONE_SIMULATOR_HOST_MIN_VERSION_REQUIRED 999999
-#endif // IPHONE_SIMULATOR_HOST_MIN_VERSION_REQUIRED
-#endif // __has_include(<simulator_host.h>)
-
-#ifndef __WATCHOS_UNAVAILABLE
-#define __WATCHOS_UNAVAILABLE
-#endif
-
-#ifndef __TVOS_UNAVAILABLE
-#define __TVOS_UNAVAILABLE
-#endif
-
-// simulator host-side bits build against SDKs not having __*_AVAILABLE() yet
-#ifndef __OSX_AVAILABLE
-#define __OSX_AVAILABLE(...)
-#endif
-
-#ifndef __IOS_AVAILABLE
-#define __IOS_AVAILABLE(...)
-#endif
-
-#ifndef __TVOS_AVAILABLE
-#define __TVOS_AVAILABLE(...)
-#endif
-
-#ifndef __WATCHOS_AVAILABLE
-#define __WATCHOS_AVAILABLE(...)
-#endif
-
-#ifndef __API_AVAILABLE
-#define __API_AVAILABLE(...)
-#endif
-
-#endif // __XPC_AVAILABILITY_H__
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/i386/_limits.h b/lib/libc/include/x86_64-macos.13-none/i386/_limits.h
similarity index 91%
rename from lib/libc/include/x86_64-macos.10-none/i386/_limits.h
rename to lib/libc/include/x86_64-macos.13-none/i386/_limits.h
index f942e7abd8..5763f5a3a8 100644
--- a/lib/libc/include/x86_64-macos.10-none/i386/_limits.h
+++ b/lib/libc/include/x86_64-macos.13-none/i386/_limits.h
@@ -22,6 +22,10 @@
 #ifndef _I386__LIMITS_H_
 #define _I386__LIMITS_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 #define __DARWIN_CLK_TCK                100     /* ticks per second */
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif  /* _I386__LIMITS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/i386/_mcontext.h b/lib/libc/include/x86_64-macos.13-none/i386/_mcontext.h
similarity index 98%
rename from lib/libc/include/x86_64-macos.10-none/i386/_mcontext.h
rename to lib/libc/include/x86_64-macos.13-none/i386/_mcontext.h
index 424ca21359..b9f40e5e33 100644
--- a/lib/libc/include/x86_64-macos.10-none/i386/_mcontext.h
+++ b/lib/libc/include/x86_64-macos.13-none/i386/_mcontext.h
@@ -29,6 +29,8 @@
 #ifndef __I386_MCONTEXT_H_
 #define __I386_MCONTEXT_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 #include <sys/cdefs.h> /* __DARWIN_UNIX03 */
 #include <sys/appleapiopts.h>
 #include <mach/machine/_structs.h>
@@ -209,4 +211,6 @@ typedef _STRUCT_MCONTEXT32      *mcontext_t;
 #endif
 #endif /* _MCONTEXT_T */
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif /* __I386_MCONTEXT_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/i386/_param.h b/lib/libc/include/x86_64-macos.13-none/i386/_param.h
similarity index 83%
rename from lib/libc/include/x86_64-macos.10-none/i386/_param.h
rename to lib/libc/include/x86_64-macos.13-none/i386/_param.h
index d8f7b3d4bf..ac0ac439aa 100644
--- a/lib/libc/include/x86_64-macos.10-none/i386/_param.h
+++ b/lib/libc/include/x86_64-macos.13-none/i386/_param.h
@@ -29,6 +29,8 @@
 #ifndef _I386__PARAM_H_
 #define _I386__PARAM_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 #include <i386/_types.h>
 
 /*
@@ -37,10 +39,11 @@
  * cast to any desired pointer type.
  */
 #define __DARWIN_ALIGNBYTES     (sizeof(__darwin_size_t) - 1)
-#define __DARWIN_ALIGN(p)       ((__darwin_size_t)((char *)(__darwin_size_t)(p) + __DARWIN_ALIGNBYTES) &~ __DARWIN_ALIGNBYTES)
+#define __DARWIN_ALIGN(p)       ((__darwin_size_t)((__darwin_size_t)(p) + __DARWIN_ALIGNBYTES) &~ __DARWIN_ALIGNBYTES)
 
 #define      __DARWIN_ALIGNBYTES32     (sizeof(__uint32_t) - 1)
-#define       __DARWIN_ALIGN32(p)       ((__darwin_size_t)((char *)(__darwin_size_t)(p) + __DARWIN_ALIGNBYTES32) &~ __DARWIN_ALIGNBYTES32)
+#define       __DARWIN_ALIGN32(p)       ((__darwin_size_t)((__darwin_size_t)(p) + __DARWIN_ALIGNBYTES32) &~ __DARWIN_ALIGNBYTES32)
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
 
 #endif /* _I386__PARAM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/i386/_types.h b/lib/libc/include/x86_64-macos.13-none/i386/_types.h
similarity index 97%
rename from lib/libc/include/x86_64-macos.10-none/i386/_types.h
rename to lib/libc/include/x86_64-macos.13-none/i386/_types.h
index 9dcffa5241..b9e77d684c 100644
--- a/lib/libc/include/x86_64-macos.10-none/i386/_types.h
+++ b/lib/libc/include/x86_64-macos.13-none/i386/_types.h
@@ -28,6 +28,8 @@
 #ifndef _BSD_I386__TYPES_H_
 #define _BSD_I386__TYPES_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 /*
  * This header file contains integer types.  It's intended to also contain
  * flotaing point and other arithmetic types, as needed, later.
@@ -119,4 +121,6 @@ typedef __uint32_t              __darwin_socklen_t;     /* socklen_t (duh) */
 typedef long                    __darwin_ssize_t;       /* byte count or error */
 typedef long                    __darwin_time_t;        /* time() */
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif  /* _BSD_I386__TYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/i386/eflags.h b/lib/libc/include/x86_64-macos.13-none/i386/eflags.h
similarity index 97%
rename from lib/libc/include/x86_64-macos.10-none/i386/eflags.h
rename to lib/libc/include/x86_64-macos.13-none/i386/eflags.h
index dc73c43126..7faa7d0839 100644
--- a/lib/libc/include/x86_64-macos.10-none/i386/eflags.h
+++ b/lib/libc/include/x86_64-macos.13-none/i386/eflags.h
@@ -59,6 +59,8 @@
 #ifndef _I386_EFLAGS_H_
 #define _I386_EFLAGS_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 /*
  *	i386 flags register
  */
@@ -91,4 +93,6 @@
 #define EFL_USER_SET    (EFL_IF)
 #define EFL_USER_CLEAR  (EFL_IOPL|EFL_NT|EFL_RF)
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif  /* _I386_EFLAGS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/i386/endian.h b/lib/libc/include/x86_64-macos.13-none/i386/endian.h
similarity index 97%
rename from lib/libc/include/x86_64-macos.10-none/i386/endian.h
rename to lib/libc/include/x86_64-macos.13-none/i386/endian.h
index 95ca16e406..104d5babca 100644
--- a/lib/libc/include/x86_64-macos.10-none/i386/endian.h
+++ b/lib/libc/include/x86_64-macos.13-none/i386/endian.h
@@ -66,6 +66,8 @@
 #ifndef _I386__ENDIAN_H_
 #define _I386__ENDIAN_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 #include <sys/cdefs.h>
 /*
  * Define _NOQUAD if the compiler does NOT support 64-bit integers.
@@ -99,4 +101,5 @@
 #include <sys/_endian.h>
 
 #endif /* defined(KERNEL) || (!defined(_POSIX_C_SOURCE) || defined(_DARWIN_C_SOURCE)) */
+#endif /* defined (__i386__) || defined (__x86_64__) */
 #endif /* !_I386__ENDIAN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/i386/limits.h b/lib/libc/include/x86_64-macos.13-none/i386/limits.h
similarity index 97%
rename from lib/libc/include/x86_64-macos.10-none/i386/limits.h
rename to lib/libc/include/x86_64-macos.13-none/i386/limits.h
index 651d770335..292e6bd654 100644
--- a/lib/libc/include/x86_64-macos.10-none/i386/limits.h
+++ b/lib/libc/include/x86_64-macos.13-none/i386/limits.h
@@ -36,6 +36,8 @@
 #ifndef _I386_LIMITS_H_
 #define _I386_LIMITS_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 #include <sys/cdefs.h>
 #include <i386/_limits.h>
 
@@ -104,4 +106,6 @@
 #endif /* (!_POSIX_C_SOURCE && !_XOPEN_SOURCE) || _DARWIN_C_SOURCE */
 #endif /* !_ANSI_SOURCE */
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif /* _I386_LIMITS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/i386/param.h b/lib/libc/include/x86_64-macos.13-none/i386/param.h
similarity index 98%
rename from lib/libc/include/x86_64-macos.10-none/i386/param.h
rename to lib/libc/include/x86_64-macos.13-none/i386/param.h
index e8eb8272e7..fe2bb9cc06 100644
--- a/lib/libc/include/x86_64-macos.10-none/i386/param.h
+++ b/lib/libc/include/x86_64-macos.13-none/i386/param.h
@@ -72,6 +72,8 @@
 #ifndef _I386_PARAM_H_
 #define _I386_PARAM_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 #include <i386/_param.h>
 
 /*
@@ -168,4 +170,6 @@
 #define DELAY(n)        { int N = (n); while (--N > 0); }
 #endif  /* defined(KERNEL) || defined(STANDALONE) */
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif /* _I386_PARAM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/i386/signal.h b/lib/libc/include/x86_64-macos.13-none/i386/signal.h
similarity index 93%
rename from lib/libc/include/x86_64-macos.10-none/i386/signal.h
rename to lib/libc/include/x86_64-macos.13-none/i386/signal.h
index cd837bb7f6..e699c2b61b 100644
--- a/lib/libc/include/x86_64-macos.10-none/i386/signal.h
+++ b/lib/libc/include/x86_64-macos.13-none/i386/signal.h
@@ -33,6 +33,8 @@
 #ifndef _I386_SIGNAL_H_
 #define _I386_SIGNAL_H_ 1
 
+#if defined (__i386__) || defined (__x86_64__)
+
 #include <sys/cdefs.h>
 
 #ifndef _ANSI_SOURCE
@@ -40,4 +42,6 @@ typedef int sig_atomic_t;
 
 #endif /* ! _ANSI_SOURCE */
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif  /* _I386_SIGNAL_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/i386/types.h b/lib/libc/include/x86_64-macos.13-none/i386/types.h
similarity index 96%
rename from lib/libc/include/x86_64-macos.10-none/i386/types.h
rename to lib/libc/include/x86_64-macos.13-none/i386/types.h
index 00dee1a917..31ffa1f37c 100644
--- a/lib/libc/include/x86_64-macos.10-none/i386/types.h
+++ b/lib/libc/include/x86_64-macos.13-none/i386/types.h
@@ -63,9 +63,12 @@
  *	@(#)types.h	8.3 (Berkeley) 1/5/94
  */
 
-#ifndef _MACHTYPES_H_
+#ifndef _I386_MACHTYPES_H_
+#define _I386_MACHTYPES_H_
 #define _MACHTYPES_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 #ifndef __ASSEMBLER__
 #include <i386/_types.h>
 #include <sys/cdefs.h>
@@ -111,4 +114,5 @@ typedef int64_t                 user_off_t;
 typedef u_int64_t               syscall_arg_t;
 
 #endif /* __ASSEMBLER__ */
-#endif  /* _MACHTYPES_H_ */
\ No newline at end of file
+#endif /* defined (__i386__) || defined (__x86_64__) */
+#endif  /* _I386_MACHTYPES_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/pthread/sched.h b/lib/libc/include/x86_64-macos.13-none/libkern/OSAtomic.h
similarity index 56%
rename from lib/libc/include/x86_64-macos.10-none/pthread/sched.h
rename to lib/libc/include/x86_64-macos.13-none/libkern/OSAtomic.h
index 3c49e7980d..37ef16ce44 100644
--- a/lib/libc/include/x86_64-macos.10-none/pthread/sched.h
+++ b/lib/libc/include/x86_64-macos.13-none/libkern/OSAtomic.h
@@ -1,15 +1,15 @@
 /*
- * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2004-2016 Apple Inc. All rights reserved.
  *
  * @APPLE_LICENSE_HEADER_START@
- * 
+ *
  * This file contains Original Code and/or Modifications of Original Code
  * as defined in and that are subject to the Apple Public Source License
  * Version 2.0 (the 'License'). You may not use this file except in
  * compliance with the License. Please obtain a copy of the License at
  * http://www.opensource.apple.com/apsl/ and read it before using this
  * file.
- * 
+ *
  * The Original Code and all software distributed under the License are
  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
@@ -17,27 +17,31 @@
  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  * Please see the License for the specific language governing rights and
  * limitations under the License.
- * 
+ *
  * @APPLE_LICENSE_HEADER_END@
  */
 
-#ifndef _SCHED_H_
-#define _SCHED_H_
+#ifndef _OSATOMIC_H_
+#define _OSATOMIC_H_
+
+/*! @header
+ * These are deprecated legacy interfaces for atomic and synchronization
+ * operations.
+ *
+ * Define OSATOMIC_USE_INLINED=1 to get inline implementations of the
+ * OSAtomic interfaces in terms of the <stdatomic.h> primitives.
+ *
+ * Define OSSPINLOCK_USE_INLINED=1 to get inline implementations of the
+ * OSSpinLock interfaces in terms of the <os/lock.h> primitives.
+ *
+ * These are intended as a transition convenience, direct use of those
+ * primitives should be preferred.
+ */
 
 #include <sys/cdefs.h>
-#include <pthread_impl.h>
 
-__BEGIN_DECLS
-/*
- * Scheduling paramters
- */
-#ifndef __POSIX_LIB__
-struct sched_param { int sched_priority;  char __opaque[__SCHED_PARAM_SIZE__]; };
-#endif
+#include "OSAtomicDeprecated.h"
+#include "OSSpinLockDeprecated.h"
+#include "OSAtomicQueue.h"
 
-extern int sched_yield(void);
-extern int sched_get_priority_min(int);
-extern int sched_get_priority_max(int);
-__END_DECLS
-
-#endif /* _SCHED_H_ */
\ No newline at end of file
+#endif /* _OSATOMIC_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.13-none/libkern/OSAtomicDeprecated.h b/lib/libc/include/x86_64-macos.13-none/libkern/OSAtomicDeprecated.h
new file mode 100644
index 0000000000..6dc880b0d4
--- /dev/null
+++ b/lib/libc/include/x86_64-macos.13-none/libkern/OSAtomicDeprecated.h
@@ -0,0 +1,1266 @@
+/*
+ * Copyright (c) 2004-2016 Apple Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ */
+
+#ifndef _OSATOMIC_DEPRECATED_H_
+#define _OSATOMIC_DEPRECATED_H_
+
+/*! @header
+ * These are deprecated legacy interfaces for atomic operations.
+ * The C11 interfaces in <stdatomic.h> resp. C++11 interfaces in <atomic>
+ * should be used instead.
+ *
+ * Define OSATOMIC_USE_INLINED=1 to get inline implementations of these
+ * interfaces in terms of the <stdatomic.h> resp. <atomic> primitives.
+ * This is intended as a transition convenience, direct use of those primitives
+ * is preferred.
+ */
+
+#include    <Availability.h>
+
+#if !(defined(OSATOMIC_USE_INLINED) && OSATOMIC_USE_INLINED)
+
+#include    <sys/cdefs.h>
+#include    <stddef.h>
+#include    <stdint.h>
+#include    <stdbool.h>
+
+#ifndef OSATOMIC_DEPRECATED
+#define OSATOMIC_DEPRECATED 1
+#ifndef __cplusplus
+#define OSATOMIC_BARRIER_DEPRECATED_MSG(_r) \
+		"Use " #_r "() from <stdatomic.h> instead"
+#define OSATOMIC_DEPRECATED_MSG(_r) \
+		"Use " #_r "_explicit(memory_order_relaxed) from <stdatomic.h> instead"
+#else
+#define OSATOMIC_BARRIER_DEPRECATED_MSG(_r) \
+		"Use std::" #_r "() from <atomic> instead"
+#define OSATOMIC_DEPRECATED_MSG(_r) \
+		"Use std::" #_r "_explicit(std::memory_order_relaxed) from <atomic> instead"
+#endif
+#define OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(_r) \
+	__OS_AVAILABILITY_MSG(macosx, deprecated=10.12, OSATOMIC_BARRIER_DEPRECATED_MSG(_r)) \
+	__OS_AVAILABILITY_MSG(ios, deprecated=10.0, OSATOMIC_BARRIER_DEPRECATED_MSG(_r)) \
+	__OS_AVAILABILITY_MSG(tvos, deprecated=10.0, OSATOMIC_BARRIER_DEPRECATED_MSG(_r)) \
+	__OS_AVAILABILITY_MSG(watchos, deprecated=3.0, OSATOMIC_BARRIER_DEPRECATED_MSG(_r))
+#define OSATOMIC_DEPRECATED_REPLACE_WITH(_r) \
+	__OS_AVAILABILITY_MSG(macosx, deprecated=10.12, OSATOMIC_DEPRECATED_MSG(_r)) \
+	__OS_AVAILABILITY_MSG(ios, deprecated=10.0, OSATOMIC_DEPRECATED_MSG(_r)) \
+	__OS_AVAILABILITY_MSG(tvos, deprecated=10.0, OSATOMIC_DEPRECATED_MSG(_r)) \
+	__OS_AVAILABILITY_MSG(watchos, deprecated=3.0, OSATOMIC_DEPRECATED_MSG(_r))
+#else
+#undef OSATOMIC_DEPRECATED
+#define OSATOMIC_DEPRECATED 0
+#define OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(_r)
+#define OSATOMIC_DEPRECATED_REPLACE_WITH(_r)
+#endif
+
+/*
+ * WARNING: all addresses passed to these functions must be "naturally aligned",
+ * i.e. <code>int32_t</code> pointers must be 32-bit aligned (low 2 bits of
+ * address are zeroes), and <code>int64_t</code> pointers must be 64-bit
+ * aligned (low 3 bits of address are zeroes.).
+ * Note that this is not the default alignment of the <code>int64_t</code> type
+ * in the iOS ARMv7 ABI, see
+ * {@link //apple_ref/doc/uid/TP40009021-SW8 iPhoneOSABIReference}
+ *
+ * Note that some versions of the atomic functions incorporate memory barriers
+ * and some do not.  Barriers strictly order memory access on weakly-ordered
+ * architectures such as ARM.  All loads and stores that appear (in sequential
+ * program order) before the barrier are guaranteed to complete before any
+ * load or store that appears after the barrier.
+ *
+ * The barrier operation is typically a no-op on uniprocessor systems and
+ * fully enabled on multiprocessor systems. On some platforms, such as ARM,
+ * the barrier can be quite expensive.
+ *
+ * Most code should use the barrier functions to ensure that memory shared
+ * between threads is properly synchronized.  For example, if you want to
+ * initialize a shared data structure and then atomically increment a variable
+ * to indicate that the initialization is complete, you must use
+ * {@link OSAtomicIncrement32Barrier} to ensure that the stores to your data
+ * structure complete before the atomic increment.
+ *
+ * Likewise, the consumer of that data structure must use
+ * {@link OSAtomicDecrement32Barrier},
+ * in order to ensure that their loads of the structure are not executed before
+ * the atomic decrement.  On the other hand, if you are simply incrementing a
+ * global counter, then it is safe and potentially faster to use
+ * {@link OSAtomicIncrement32}.
+ *
+ * If you are unsure which version to use, prefer the barrier variants as they
+ * are safer.
+ *
+ * For the kernel-space version of this header, see
+ * {@link //apple_ref/doc/header/OSAtomic.h OSAtomic.h (Kernel Framework)}
+ *
+ * @apiuid //apple_ref/doc/header/user_space_OSAtomic.h
+ */
+
+__BEGIN_DECLS
+
+/*! @typedef OSAtomic_int64_aligned64_t
+ * 64-bit aligned <code>int64_t</code> type.
+ * Use for variables whose addresses are passed to OSAtomic*64() functions to
+ * get the compiler to generate the required alignment.
+ */
+
+#if __has_attribute(aligned)
+typedef int64_t __attribute__((__aligned__((sizeof(int64_t)))))
+		OSAtomic_int64_aligned64_t;
+#else
+typedef int64_t OSAtomic_int64_aligned64_t;
+#endif
+
+/*! @group Arithmetic functions
+    All functions in this group return the new value.
+ */
+
+/*! @abstract Atomically adds two 32-bit values.
+    @discussion
+	This function adds the value given by <code>__theAmount</code> to the
+	value in the memory location referenced by <code>__theValue</code>,
+ 	storing the result back to that memory location atomically.
+    @result Returns the new value.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+int32_t	OSAtomicAdd32( int32_t __theAmount, volatile int32_t *__theValue );
+
+
+/*! @abstract Atomically adds two 32-bit values.
+    @discussion
+	This function adds the value given by <code>__theAmount</code> to the
+	value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicAdd32}
+	except that it also introduces a barrier.
+    @result Returns the new value.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+int32_t	OSAtomicAdd32Barrier( int32_t __theAmount, volatile int32_t *__theValue );
+
+
+#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_10 || __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_1 || TARGET_OS_DRIVERKIT
+
+/*! @abstract Atomically increments a 32-bit value.
+    @result Returns the new value.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
+__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
+int32_t	OSAtomicIncrement32( volatile int32_t *__theValue );
+
+
+/*! @abstract Atomically increments a 32-bit value with a barrier.
+    @discussion
+	This function is equivalent to {@link OSAtomicIncrement32}
+	except that it also introduces a barrier.
+    @result Returns the new value.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
+__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
+int32_t	OSAtomicIncrement32Barrier( volatile int32_t *__theValue );
+
+
+/*! @abstract Atomically decrements a 32-bit value.
+    @result Returns the new value.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_sub)
+__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
+int32_t	OSAtomicDecrement32( volatile int32_t *__theValue );
+
+
+/*! @abstract Atomically decrements a 32-bit value with a barrier.
+    @discussion
+	This function is equivalent to {@link OSAtomicDecrement32}
+	except that it also introduces a barrier.
+    @result Returns the new value.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_sub)
+__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
+int32_t	OSAtomicDecrement32Barrier( volatile int32_t *__theValue );
+
+#else
+__inline static
+int32_t	OSAtomicIncrement32( volatile int32_t *__theValue )
+            { return OSAtomicAdd32(  1, __theValue); }
+
+__inline static
+int32_t	OSAtomicIncrement32Barrier( volatile int32_t *__theValue )
+            { return OSAtomicAdd32Barrier(  1, __theValue); }
+
+__inline static
+int32_t	OSAtomicDecrement32( volatile int32_t *__theValue )
+            { return OSAtomicAdd32( -1, __theValue); }
+
+__inline static
+int32_t	OSAtomicDecrement32Barrier( volatile int32_t *__theValue )
+            { return OSAtomicAdd32Barrier( -1, __theValue); }
+#endif
+
+
+/*! @abstract Atomically adds two 64-bit values.
+    @discussion
+	This function adds the value given by <code>__theAmount</code> to the
+	value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+    @result Returns the new value.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+int64_t	OSAtomicAdd64( int64_t __theAmount,
+		volatile OSAtomic_int64_aligned64_t *__theValue );
+
+
+/*! @abstract Atomically adds two 64-bit values with a barrier.
+    @discussion
+	This function adds the value given by <code>__theAmount</code> to the
+	value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicAdd64}
+	except that it also introduces a barrier.
+    @result Returns the new value.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_3_2)
+int64_t	OSAtomicAdd64Barrier( int64_t __theAmount,
+		volatile OSAtomic_int64_aligned64_t *__theValue );
+
+
+#if __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_10_10 || __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_7_1 || TARGET_OS_DRIVERKIT
+
+/*! @abstract Atomically increments a 64-bit value.
+    @result Returns the new value.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
+__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
+int64_t	OSAtomicIncrement64( volatile OSAtomic_int64_aligned64_t *__theValue );
+
+
+/*! @abstract Atomically increments a 64-bit value with a barrier.
+    @discussion
+	This function is equivalent to {@link OSAtomicIncrement64}
+	except that it also introduces a barrier.
+    @result Returns the new value.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_add)
+__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
+int64_t	OSAtomicIncrement64Barrier( volatile OSAtomic_int64_aligned64_t *__theValue );
+
+
+/*! @abstract Atomically decrements a 64-bit value.
+    @result Returns the new value.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_sub)
+__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
+int64_t	OSAtomicDecrement64( volatile OSAtomic_int64_aligned64_t *__theValue );
+
+
+/*! @abstract Atomically decrements a 64-bit value with a barrier.
+    @discussion
+	This function is equivalent to {@link OSAtomicDecrement64}
+	except that it also introduces a barrier.
+    @result Returns the new value.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_sub)
+__OSX_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_7_1)
+int64_t	OSAtomicDecrement64Barrier( volatile OSAtomic_int64_aligned64_t *__theValue );
+
+#else
+__inline static
+int64_t	OSAtomicIncrement64( volatile OSAtomic_int64_aligned64_t *__theValue )
+            { return OSAtomicAdd64(  1, __theValue); }
+
+__inline static
+int64_t	OSAtomicIncrement64Barrier( volatile OSAtomic_int64_aligned64_t *__theValue )
+            { return OSAtomicAdd64Barrier(  1, __theValue); }
+
+__inline static
+int64_t	OSAtomicDecrement64( volatile OSAtomic_int64_aligned64_t *__theValue )
+            { return OSAtomicAdd64( -1, __theValue); }
+
+__inline static
+int64_t	OSAtomicDecrement64Barrier( volatile OSAtomic_int64_aligned64_t *__theValue )
+            { return OSAtomicAdd64Barrier( -1, __theValue); }
+#endif
+
+
+/*! @group Boolean functions (AND, OR, XOR)
+ *
+ * @discussion Functions in this group come in four variants for each operation:
+ * with and without barriers, and functions that return the original value or
+ * the result value of the operation.
+ *
+ * The "Orig" versions return the original value, (before the operation); the non-Orig
+ * versions return the value after the operation.  All are layered on top of
+ * {@link OSAtomicCompareAndSwap32} and similar.
+ */
+
+/*! @abstract Atomic bitwise OR of two 32-bit values.
+    @discussion
+	This function performs the bitwise OR of the value given by <code>__theMask</code>
+	with the value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+    @result Returns the new value.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_or)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+int32_t	OSAtomicOr32( uint32_t __theMask, volatile uint32_t *__theValue );
+
+
+/*! @abstract Atomic bitwise OR of two 32-bit values with barrier.
+    @discussion
+	This function performs the bitwise OR of the value given by <code>__theMask</code>
+	with the value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicOr32}
+	except that it also introduces a barrier.
+    @result Returns the new value.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_or)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+int32_t	OSAtomicOr32Barrier( uint32_t __theMask, volatile uint32_t *__theValue );
+
+
+/*! @abstract Atomic bitwise OR of two 32-bit values returning original.
+    @discussion
+	This function performs the bitwise OR of the value given by <code>__theMask</code>
+	with the value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+    @result Returns the original value referenced by <code>__theValue</code>.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_or)
+__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_2)
+int32_t	OSAtomicOr32Orig( uint32_t __theMask, volatile uint32_t *__theValue );
+
+
+/*! @abstract Atomic bitwise OR of two 32-bit values returning original with barrier.
+    @discussion
+	This function performs the bitwise OR of the value given by <code>__theMask</code>
+	with the value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicOr32Orig}
+	except that it also introduces a barrier.
+    @result Returns the original value referenced by <code>__theValue</code>.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_or)
+__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_2)
+int32_t	OSAtomicOr32OrigBarrier( uint32_t __theMask, volatile uint32_t *__theValue );
+
+
+
+
+/*! @abstract Atomic bitwise AND of two 32-bit values.
+    @discussion
+	This function performs the bitwise AND of the value given by <code>__theMask</code>
+	with the value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+    @result Returns the new value.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_and)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+int32_t	OSAtomicAnd32( uint32_t __theMask, volatile uint32_t *__theValue );
+
+
+/*! @abstract Atomic bitwise AND of two 32-bit values with barrier.
+    @discussion
+	This function performs the bitwise AND of the value given by <code>__theMask</code>
+	with the value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicAnd32}
+	except that it also introduces a barrier.
+    @result Returns the new value.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_and)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+int32_t	OSAtomicAnd32Barrier( uint32_t __theMask, volatile uint32_t *__theValue );
+
+
+/*! @abstract Atomic bitwise AND of two 32-bit values returning original.
+    @discussion
+	This function performs the bitwise AND of the value given by <code>__theMask</code>
+	with the value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+    @result Returns the original value referenced by <code>__theValue</code>.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_and)
+__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_2)
+int32_t	OSAtomicAnd32Orig( uint32_t __theMask, volatile uint32_t *__theValue );
+
+
+/*! @abstract Atomic bitwise AND of two 32-bit values returning original with barrier.
+    @discussion
+	This function performs the bitwise AND of the value given by <code>__theMask</code>
+	with the value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicAnd32Orig}
+	except that it also introduces a barrier.
+    @result Returns the original value referenced by <code>__theValue</code>.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_and)
+__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_2)
+int32_t	OSAtomicAnd32OrigBarrier( uint32_t __theMask, volatile uint32_t *__theValue );
+
+
+
+
+/*! @abstract Atomic bitwise XOR of two 32-bit values.
+    @discussion
+	This function performs the bitwise XOR of the value given by <code>__theMask</code>
+	with the value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+    @result Returns the new value.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_xor)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+int32_t	OSAtomicXor32( uint32_t __theMask, volatile uint32_t *__theValue );
+
+
+/*! @abstract Atomic bitwise XOR of two 32-bit values with barrier.
+    @discussion
+	This function performs the bitwise XOR of the value given by <code>__theMask</code>
+	with the value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicXor32}
+	except that it also introduces a barrier.
+    @result Returns the new value.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_xor)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+int32_t	OSAtomicXor32Barrier( uint32_t __theMask, volatile uint32_t *__theValue );
+
+
+/*! @abstract Atomic bitwise XOR of two 32-bit values returning original.
+    @discussion
+	This function performs the bitwise XOR of the value given by <code>__theMask</code>
+	with the value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+    @result Returns the original value referenced by <code>__theValue</code>.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_xor)
+__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_2)
+int32_t	OSAtomicXor32Orig( uint32_t __theMask, volatile uint32_t *__theValue );
+
+
+/*! @abstract Atomic bitwise XOR of two 32-bit values returning original with barrier.
+    @discussion
+	This function performs the bitwise XOR of the value given by <code>__theMask</code>
+	with the value in the memory location referenced by <code>__theValue</code>,
+	storing the result back to that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicXor32Orig}
+	except that it also introduces a barrier.
+    @result Returns the original value referenced by <code>__theValue</code>.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_xor)
+__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_3_2)
+int32_t	OSAtomicXor32OrigBarrier( uint32_t __theMask, volatile uint32_t *__theValue );
+
+
+/*! @group Compare and swap
+ * Functions in this group return true if the swap occured.  There are several versions,
+ * depending on data type and on whether or not a barrier is used.
+ */
+
+
+/*! @abstract Compare and swap for 32-bit values.
+    @discussion
+	This function compares the value in <code>__oldValue</code> to the value
+	in the memory location referenced by <code>__theValue</code>.  If the values
+	match, this function stores the value from <code>__newValue</code> into
+	that memory location atomically.
+    @result Returns TRUE on a match, FALSE otherwise.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+bool    OSAtomicCompareAndSwap32( int32_t __oldValue, int32_t __newValue, volatile int32_t *__theValue );
+
+
+/*! @abstract Compare and swap for 32-bit values with barrier.
+    @discussion
+	This function compares the value in <code>__oldValue</code> to the value
+	in the memory location referenced by <code>__theValue</code>.  If the values
+	match, this function stores the value from <code>__newValue</code> into
+	that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicCompareAndSwap32}
+	except that it also introduces a barrier.
+    @result Returns TRUE on a match, FALSE otherwise.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+bool    OSAtomicCompareAndSwap32Barrier( int32_t __oldValue, int32_t __newValue, volatile int32_t *__theValue );
+
+
+/*! @abstract Compare and swap pointers.
+    @discussion
+	This function compares the pointer stored in <code>__oldValue</code> to the pointer
+	in the memory location referenced by <code>__theValue</code>.  If the pointers
+	match, this function stores the pointer from <code>__newValue</code> into
+	that memory location atomically.
+    @result Returns TRUE on a match, FALSE otherwise.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
+__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0)
+bool	OSAtomicCompareAndSwapPtr( void *__oldValue, void *__newValue, void * volatile *__theValue );
+
+
+/*! @abstract Compare and swap pointers with barrier.
+    @discussion
+	This function compares the pointer stored in <code>__oldValue</code> to the pointer
+	in the memory location referenced by <code>__theValue</code>.  If the pointers
+	match, this function stores the pointer from <code>__newValue</code> into
+	that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicCompareAndSwapPtr}
+	except that it also introduces a barrier.
+    @result Returns TRUE on a match, FALSE otherwise.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
+__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0)
+bool	OSAtomicCompareAndSwapPtrBarrier( void *__oldValue, void *__newValue, void * volatile *__theValue );
+
+
+/*! @abstract Compare and swap for <code>int</code> values.
+    @discussion
+	This function compares the value in <code>__oldValue</code> to the value
+	in the memory location referenced by <code>__theValue</code>.  If the values
+	match, this function stores the value from <code>__newValue</code> into
+	that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicCompareAndSwap32}.
+    @result Returns TRUE on a match, FALSE otherwise.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
+__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0)
+bool	OSAtomicCompareAndSwapInt( int __oldValue, int __newValue, volatile int *__theValue );
+
+
+/*! @abstract Compare and swap for <code>int</code> values.
+    @discussion
+	This function compares the value in <code>__oldValue</code> to the value
+	in the memory location referenced by <code>__theValue</code>.  If the values
+	match, this function stores the value from <code>__newValue</code> into
+	that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicCompareAndSwapInt}
+	except that it also introduces a barrier.
+
+	This function is equivalent to {@link OSAtomicCompareAndSwap32Barrier}.
+    @result Returns TRUE on a match, FALSE otherwise.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
+__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0)
+bool	OSAtomicCompareAndSwapIntBarrier( int __oldValue, int __newValue, volatile int *__theValue );
+
+
+/*! @abstract Compare and swap for <code>long</code> values.
+    @discussion
+	This function compares the value in <code>__oldValue</code> to the value
+	in the memory location referenced by <code>__theValue</code>.  If the values
+	match, this function stores the value from <code>__newValue</code> into
+	that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicCompareAndSwap32} on 32-bit architectures,
+	or {@link OSAtomicCompareAndSwap64} on 64-bit architectures.
+    @result Returns TRUE on a match, FALSE otherwise.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
+__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0)
+bool	OSAtomicCompareAndSwapLong( long __oldValue, long __newValue, volatile long *__theValue );
+
+
+/*! @abstract Compare and swap for <code>long</code> values.
+    @discussion
+	This function compares the value in <code>__oldValue</code> to the value
+	in the memory location referenced by <code>__theValue</code>.  If the values
+	match, this function stores the value from <code>__newValue</code> into
+	that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicCompareAndSwapLong}
+	except that it also introduces a barrier.
+
+	This function is equivalent to {@link OSAtomicCompareAndSwap32} on 32-bit architectures,
+	or {@link OSAtomicCompareAndSwap64} on 64-bit architectures.
+    @result Returns TRUE on a match, FALSE otherwise.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
+__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0)
+bool	OSAtomicCompareAndSwapLongBarrier( long __oldValue, long __newValue, volatile long *__theValue );
+
+
+/*! @abstract Compare and swap for <code>uint64_t</code> values.
+    @discussion
+	This function compares the value in <code>__oldValue</code> to the value
+	in the memory location referenced by <code>__theValue</code>.  If the values
+	match, this function stores the value from <code>__newValue</code> into
+	that memory location atomically.
+    @result Returns TRUE on a match, FALSE otherwise.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+bool    OSAtomicCompareAndSwap64( int64_t __oldValue, int64_t __newValue,
+		volatile OSAtomic_int64_aligned64_t *__theValue );
+
+
+/*! @abstract Compare and swap for <code>uint64_t</code> values.
+    @discussion
+	This function compares the value in <code>__oldValue</code> to the value
+	in the memory location referenced by <code>__theValue</code>.  If the values
+	match, this function stores the value from <code>__newValue</code> into
+	that memory location atomically.
+
+	This function is equivalent to {@link OSAtomicCompareAndSwap64}
+	except that it also introduces a barrier.
+    @result Returns TRUE on a match, FALSE otherwise.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_compare_exchange_strong)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_3_2)
+bool    OSAtomicCompareAndSwap64Barrier( int64_t __oldValue, int64_t __newValue,
+		volatile OSAtomic_int64_aligned64_t *__theValue );
+
+
+/* Test and set.
+ * They return the original value of the bit, and operate on bit (0x80>>(n&7))
+ * in byte ((char*)theAddress + (n>>3)).
+ */
+/*! @abstract Atomic test and set
+    @discussion
+	This function tests a bit in the value referenced by
+	<code>__theAddress</code> and if it is not set, sets it.
+
+	The bit is chosen by the value of <code>__n</code> such that the
+	operation will be performed on bit <code>(0x80 >> (__n & 7))</code>
+	of byte <code>((char *)__theAddress + (n >> 3))</code>.
+
+	For example, if <code>__theAddress</code> points to a 64-bit value,
+	to compare the value of the most significant bit, you would specify
+	<code>56</code> for <code>__n</code>.
+    @result
+	Returns the original value of the bit being tested.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_or)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+bool    OSAtomicTestAndSet( uint32_t __n, volatile void *__theAddress );
+
+
+/*! @abstract Atomic test and set with barrier
+    @discussion
+	This function tests a bit in the value referenced by <code>__theAddress</code>
+	and if it is not set, sets it.
+
+	The bit is chosen by the value of <code>__n</code> such that the
+	operation will be performed on bit <code>(0x80 >> (__n & 7))</code>
+	of byte <code>((char *)__theAddress + (n >> 3))</code>.
+
+	For example, if <code>__theAddress</code> points to a 64-bit value,
+	to compare the value of the most significant bit, you would specify
+	<code>56</code> for <code>__n</code>.
+
+	This function is equivalent to {@link OSAtomicTestAndSet}
+	except that it also introduces a barrier.
+    @result
+	Returns the original value of the bit being tested.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_or)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+bool    OSAtomicTestAndSetBarrier( uint32_t __n, volatile void *__theAddress );
+
+
+
+/*! @abstract Atomic test and clear
+    @discussion
+	This function tests a bit in the value referenced by <code>__theAddress</code>
+	and if it is not cleared, clears it.
+
+	The bit is chosen by the value of <code>__n</code> such that the
+	operation will be performed on bit <code>(0x80 >> (__n & 7))</code>
+	of byte <code>((char *)__theAddress + (n >> 3))</code>.
+
+	For example, if <code>__theAddress</code> points to a 64-bit value,
+	to compare the value of the most significant bit, you would specify
+	<code>56</code> for <code>__n</code>.
+
+    @result
+	Returns the original value of the bit being tested.
+ */
+OSATOMIC_DEPRECATED_REPLACE_WITH(atomic_fetch_and)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+bool    OSAtomicTestAndClear( uint32_t __n, volatile void *__theAddress );
+
+
+/*! @abstract Atomic test and clear
+    @discussion
+	This function tests a bit in the value referenced by <code>__theAddress</code>
+	and if it is not cleared, clears it.
+
+	The bit is chosen by the value of <code>__n</code> such that the
+	operation will be performed on bit <code>(0x80 >> (__n & 7))</code>
+	of byte <code>((char *)__theAddress + (n >> 3))</code>.
+
+	For example, if <code>__theAddress</code> points to a 64-bit value,
+	to compare the value of the most significant bit, you would specify
+	<code>56</code> for <code>__n</code>.
+
+	This function is equivalent to {@link OSAtomicTestAndSet}
+	except that it also introduces a barrier.
+    @result
+	Returns the original value of the bit being tested.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_fetch_and)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+bool    OSAtomicTestAndClearBarrier( uint32_t __n, volatile void *__theAddress );
+
+
+/*! @group Memory barriers */
+
+/*! @abstract Memory barrier.
+    @discussion
+	This function serves as both a read and write barrier.
+ */
+OSATOMIC_BARRIER_DEPRECATED_REPLACE_WITH(atomic_thread_fence)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+void    OSMemoryBarrier( void );
+
+__END_DECLS
+
+#else // defined(OSATOMIC_USE_INLINED) && OSATOMIC_USE_INLINED
+
+/*
+ * Inline implementations of the legacy OSAtomic interfaces in terms of
+ * C11 <stdatomic.h> resp. C++11 <atomic> primitives.
+ * Direct use of those primitives is preferred.
+ */
+
+#include <sys/cdefs.h>
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C++" {
+#if !(__has_include(<atomic>) && __has_extension(cxx_atomic))
+#error Cannot use inlined OSAtomic without <atomic> and C++11 atomics
+#endif
+#include <atomic>
+typedef std::atomic<uint8_t> _OSAtomic_uint8_t;
+typedef std::atomic<int32_t> _OSAtomic_int32_t;
+typedef std::atomic<uint32_t> _OSAtomic_uint32_t;
+typedef std::atomic<int64_t> _OSAtomic_int64_t;
+typedef std::atomic<void*> _OSAtomic_void_ptr_t;
+#define OSATOMIC_STD(_a) std::_a
+__BEGIN_DECLS
+#else
+#if !(__has_include(<stdatomic.h>) && __has_extension(c_atomic))
+#error Cannot use inlined OSAtomic without <stdatomic.h> and C11 atomics
+#endif
+#include <stdatomic.h>
+typedef _Atomic(uint8_t) _OSAtomic_uint8_t;
+typedef _Atomic(int32_t) _OSAtomic_int32_t;
+typedef _Atomic(uint32_t) _OSAtomic_uint32_t;
+typedef _Atomic(int64_t) _OSAtomic_int64_t;
+typedef _Atomic(void*) _OSAtomic_void_ptr_t;
+#define OSATOMIC_STD(_a) _a
+#endif
+
+#if __has_extension(c_alignof) && __has_attribute(aligned)
+typedef int64_t __attribute__((__aligned__(_Alignof(_OSAtomic_int64_t))))
+		OSAtomic_int64_aligned64_t;
+#elif __has_attribute(aligned)
+typedef int64_t __attribute__((__aligned__((sizeof(_OSAtomic_int64_t)))))
+		OSAtomic_int64_aligned64_t;
+#else
+typedef int64_t OSAtomic_int64_aligned64_t;
+#endif
+
+#if __has_attribute(always_inline)
+#define OSATOMIC_INLINE static __inline __attribute__((__always_inline__))
+#else
+#define OSATOMIC_INLINE static __inline
+#endif
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicAdd32(int32_t __theAmount, volatile int32_t *__theValue)
+{
+	return (OSATOMIC_STD(atomic_fetch_add_explicit)(
+			(volatile _OSAtomic_int32_t*) __theValue, __theAmount,
+			OSATOMIC_STD(memory_order_relaxed)) + __theAmount);
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicAdd32Barrier(int32_t __theAmount, volatile int32_t *__theValue)
+{
+	return (OSATOMIC_STD(atomic_fetch_add_explicit)(
+			(volatile _OSAtomic_int32_t*) __theValue, __theAmount,
+			OSATOMIC_STD(memory_order_seq_cst)) + __theAmount);
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicIncrement32(volatile int32_t *__theValue)
+{
+	return OSAtomicAdd32(1, __theValue);
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicIncrement32Barrier(volatile int32_t *__theValue)
+{
+	return OSAtomicAdd32Barrier(1, __theValue);
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicDecrement32(volatile int32_t *__theValue)
+{
+	return OSAtomicAdd32(-1, __theValue);
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicDecrement32Barrier(volatile int32_t *__theValue)
+{
+	return OSAtomicAdd32Barrier(-1, __theValue);
+}
+
+OSATOMIC_INLINE
+int64_t
+OSAtomicAdd64(int64_t __theAmount,
+		volatile OSAtomic_int64_aligned64_t *__theValue)
+{
+	return (OSATOMIC_STD(atomic_fetch_add_explicit)(
+			(volatile _OSAtomic_int64_t*) __theValue, __theAmount,
+			OSATOMIC_STD(memory_order_relaxed)) + __theAmount);
+}
+
+OSATOMIC_INLINE
+int64_t
+OSAtomicAdd64Barrier(int64_t __theAmount,
+		volatile OSAtomic_int64_aligned64_t *__theValue)
+{
+	return (OSATOMIC_STD(atomic_fetch_add_explicit)(
+			(volatile _OSAtomic_int64_t*) __theValue, __theAmount,
+			OSATOMIC_STD(memory_order_seq_cst)) + __theAmount);
+}
+
+OSATOMIC_INLINE
+int64_t
+OSAtomicIncrement64(volatile OSAtomic_int64_aligned64_t *__theValue)
+{
+	return OSAtomicAdd64(1, __theValue);
+}
+
+OSATOMIC_INLINE
+int64_t
+OSAtomicIncrement64Barrier(volatile OSAtomic_int64_aligned64_t *__theValue)
+{
+	return OSAtomicAdd64Barrier(1, __theValue);
+}
+
+OSATOMIC_INLINE
+int64_t
+OSAtomicDecrement64(volatile OSAtomic_int64_aligned64_t *__theValue)
+{
+	return OSAtomicAdd64(-1, __theValue);
+}
+
+OSATOMIC_INLINE
+int64_t
+OSAtomicDecrement64Barrier(volatile OSAtomic_int64_aligned64_t *__theValue)
+{
+	return OSAtomicAdd64Barrier(-1, __theValue);
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicOr32(uint32_t __theMask, volatile uint32_t *__theValue)
+{
+	return (int32_t)(OSATOMIC_STD(atomic_fetch_or_explicit)(
+			(volatile _OSAtomic_uint32_t*)__theValue, __theMask,
+			OSATOMIC_STD(memory_order_relaxed)) | __theMask);
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicOr32Barrier(uint32_t __theMask, volatile uint32_t *__theValue)
+{
+	return (int32_t)(OSATOMIC_STD(atomic_fetch_or_explicit)(
+			(volatile _OSAtomic_uint32_t*)__theValue, __theMask,
+			OSATOMIC_STD(memory_order_seq_cst)) | __theMask);
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicOr32Orig(uint32_t __theMask, volatile uint32_t *__theValue)
+{
+	return (int32_t)(OSATOMIC_STD(atomic_fetch_or_explicit)(
+			(volatile _OSAtomic_uint32_t*)__theValue, __theMask,
+			OSATOMIC_STD(memory_order_relaxed)));
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicOr32OrigBarrier(uint32_t __theMask, volatile uint32_t *__theValue)
+{
+	return (int32_t)(OSATOMIC_STD(atomic_fetch_or_explicit)(
+			(volatile _OSAtomic_uint32_t*)__theValue, __theMask,
+			OSATOMIC_STD(memory_order_seq_cst)));
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicAnd32(uint32_t __theMask, volatile uint32_t *__theValue)
+{
+	return (int32_t)(OSATOMIC_STD(atomic_fetch_and_explicit)(
+			(volatile _OSAtomic_uint32_t*)__theValue, __theMask,
+			OSATOMIC_STD(memory_order_relaxed)) & __theMask);
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicAnd32Barrier(uint32_t __theMask, volatile uint32_t *__theValue)
+{
+	return (int32_t)(OSATOMIC_STD(atomic_fetch_and_explicit)(
+			(volatile _OSAtomic_uint32_t*)__theValue, __theMask,
+			OSATOMIC_STD(memory_order_seq_cst)) & __theMask);
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicAnd32Orig(uint32_t __theMask, volatile uint32_t *__theValue)
+{
+	return (int32_t)(OSATOMIC_STD(atomic_fetch_and_explicit)(
+			(volatile _OSAtomic_uint32_t*)__theValue, __theMask,
+			OSATOMIC_STD(memory_order_relaxed)));
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicAnd32OrigBarrier(uint32_t __theMask, volatile uint32_t *__theValue)
+{
+	return (int32_t)(OSATOMIC_STD(atomic_fetch_and_explicit)(
+			(volatile _OSAtomic_uint32_t*)__theValue, __theMask,
+			OSATOMIC_STD(memory_order_seq_cst)));
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicXor32(uint32_t __theMask, volatile uint32_t *__theValue)
+{
+	return (int32_t)(OSATOMIC_STD(atomic_fetch_xor_explicit)(
+			(volatile _OSAtomic_uint32_t*)__theValue, __theMask,
+			OSATOMIC_STD(memory_order_relaxed)) ^ __theMask);
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicXor32Barrier(uint32_t __theMask, volatile uint32_t *__theValue)
+{
+	return (int32_t)(OSATOMIC_STD(atomic_fetch_xor_explicit)(
+			(volatile _OSAtomic_uint32_t*)__theValue, __theMask,
+			OSATOMIC_STD(memory_order_seq_cst)) ^ __theMask);
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicXor32Orig(uint32_t __theMask, volatile uint32_t *__theValue)
+{
+	return (int32_t)(OSATOMIC_STD(atomic_fetch_xor_explicit)(
+			(volatile _OSAtomic_uint32_t*)__theValue, __theMask,
+			OSATOMIC_STD(memory_order_relaxed)));
+}
+
+OSATOMIC_INLINE
+int32_t
+OSAtomicXor32OrigBarrier(uint32_t __theMask, volatile uint32_t *__theValue)
+{
+	return (int32_t)(OSATOMIC_STD(atomic_fetch_xor_explicit)(
+			(volatile _OSAtomic_uint32_t*)__theValue, __theMask,
+			OSATOMIC_STD(memory_order_seq_cst)));
+}
+
+OSATOMIC_INLINE
+bool
+OSAtomicCompareAndSwap32(int32_t __oldValue, int32_t __newValue,
+		volatile int32_t *__theValue)
+{
+	return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
+			(volatile _OSAtomic_int32_t*)__theValue, &__oldValue, __newValue,
+			OSATOMIC_STD(memory_order_relaxed),
+			OSATOMIC_STD(memory_order_relaxed)));
+}
+
+OSATOMIC_INLINE
+bool
+OSAtomicCompareAndSwap32Barrier(int32_t __oldValue, int32_t __newValue,
+		volatile int32_t *__theValue)
+{
+	return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
+			(volatile _OSAtomic_int32_t*)__theValue, &__oldValue, __newValue,
+			OSATOMIC_STD(memory_order_seq_cst),
+			OSATOMIC_STD(memory_order_relaxed)));
+}
+
+OSATOMIC_INLINE
+bool
+OSAtomicCompareAndSwapPtr(void *__oldValue, void *__newValue,
+		void * volatile *__theValue)
+{
+	return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
+			(volatile _OSAtomic_void_ptr_t*)__theValue, &__oldValue, __newValue,
+			OSATOMIC_STD(memory_order_relaxed),
+			OSATOMIC_STD(memory_order_relaxed)));
+}
+
+OSATOMIC_INLINE
+bool
+OSAtomicCompareAndSwapPtrBarrier(void *__oldValue, void *__newValue,
+		void * volatile *__theValue)
+{
+	return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
+			(volatile _OSAtomic_void_ptr_t*)__theValue, &__oldValue, __newValue,
+			OSATOMIC_STD(memory_order_seq_cst),
+			OSATOMIC_STD(memory_order_relaxed)));
+}
+
+OSATOMIC_INLINE
+bool
+OSAtomicCompareAndSwapInt(int __oldValue, int __newValue,
+		volatile int *__theValue)
+{
+	return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
+			(volatile OSATOMIC_STD(atomic_int)*)__theValue, &__oldValue,
+			__newValue, OSATOMIC_STD(memory_order_relaxed),
+			OSATOMIC_STD(memory_order_relaxed)));
+}
+
+OSATOMIC_INLINE
+bool
+OSAtomicCompareAndSwapIntBarrier(int __oldValue, int __newValue,
+		volatile int *__theValue)
+{
+	return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
+			(volatile OSATOMIC_STD(atomic_int)*)__theValue, &__oldValue,
+			__newValue, OSATOMIC_STD(memory_order_seq_cst),
+			OSATOMIC_STD(memory_order_relaxed)));
+}
+
+OSATOMIC_INLINE
+bool
+OSAtomicCompareAndSwapLong(long __oldValue, long __newValue,
+		volatile long *__theValue)
+{
+	return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
+			(volatile OSATOMIC_STD(atomic_long)*)__theValue, &__oldValue,
+			__newValue, OSATOMIC_STD(memory_order_relaxed),
+			OSATOMIC_STD(memory_order_relaxed)));
+}
+
+OSATOMIC_INLINE
+bool
+OSAtomicCompareAndSwapLongBarrier(long __oldValue, long __newValue,
+		volatile long *__theValue)
+{
+	return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
+			(volatile OSATOMIC_STD(atomic_long)*)__theValue, &__oldValue,
+			__newValue, OSATOMIC_STD(memory_order_seq_cst),
+			OSATOMIC_STD(memory_order_relaxed)));
+}
+
+OSATOMIC_INLINE
+bool
+OSAtomicCompareAndSwap64(int64_t __oldValue, int64_t __newValue,
+		volatile OSAtomic_int64_aligned64_t *__theValue)
+{
+	return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
+			(volatile _OSAtomic_int64_t*)__theValue, &__oldValue, __newValue,
+			OSATOMIC_STD(memory_order_relaxed),
+			OSATOMIC_STD(memory_order_relaxed)));
+}
+
+OSATOMIC_INLINE
+bool
+OSAtomicCompareAndSwap64Barrier(int64_t __oldValue, int64_t __newValue,
+		volatile OSAtomic_int64_aligned64_t *__theValue)
+{
+	return (OSATOMIC_STD(atomic_compare_exchange_strong_explicit)(
+			(volatile _OSAtomic_int64_t*)__theValue, &__oldValue, __newValue,
+			OSATOMIC_STD(memory_order_seq_cst),
+			OSATOMIC_STD(memory_order_relaxed)));
+}
+
+OSATOMIC_INLINE
+bool
+OSAtomicTestAndSet(uint32_t __n, volatile void *__theAddress)
+{
+	uintptr_t a = (uintptr_t)__theAddress + (__n >> 3);
+	uint8_t v = (0x80u >> (__n & 7));
+	return (OSATOMIC_STD(atomic_fetch_or_explicit)((_OSAtomic_uint8_t*)a, v,
+			OSATOMIC_STD(memory_order_relaxed)) & v);
+}
+
+OSATOMIC_INLINE
+bool
+OSAtomicTestAndSetBarrier(uint32_t __n, volatile void *__theAddress)
+{
+	uintptr_t a = (uintptr_t)__theAddress + (__n >> 3);
+	uint8_t v = (0x80u >> (__n & 7));
+	return (OSATOMIC_STD(atomic_fetch_or_explicit)((_OSAtomic_uint8_t*)a, v,
+			OSATOMIC_STD(memory_order_seq_cst)) & v);
+}
+
+OSATOMIC_INLINE
+bool
+OSAtomicTestAndClear(uint32_t __n, volatile void *__theAddress)
+{
+	uintptr_t a = (uintptr_t)__theAddress + (__n >> 3);
+	uint8_t v = (0x80u >> (__n & 7));
+	return (OSATOMIC_STD(atomic_fetch_and_explicit)((_OSAtomic_uint8_t*)a,
+			(uint8_t)~v, OSATOMIC_STD(memory_order_relaxed)) & v);
+}
+
+OSATOMIC_INLINE
+bool
+OSAtomicTestAndClearBarrier(uint32_t __n, volatile void *__theAddress)
+{
+	uintptr_t a = (uintptr_t)__theAddress + (__n >> 3);
+	uint8_t v = (0x80u >> (__n & 7));
+	return (OSATOMIC_STD(atomic_fetch_and_explicit)((_OSAtomic_uint8_t*)a,
+			(uint8_t)~v, OSATOMIC_STD(memory_order_seq_cst)) & v);
+}
+
+OSATOMIC_INLINE
+void
+OSMemoryBarrier(void)
+{
+	OSATOMIC_STD(atomic_thread_fence)(OSATOMIC_STD(memory_order_seq_cst));
+}
+
+#undef OSATOMIC_INLINE
+#undef OSATOMIC_STD
+#ifdef __cplusplus
+__END_DECLS
+} // extern "C++"
+#endif
+
+#endif // defined(OSATOMIC_USE_INLINED) && OSATOMIC_USE_INLINED
+
+#if TARGET_OS_OSX || TARGET_OS_DRIVERKIT
+
+__BEGIN_DECLS
+
+/*! @group Lockless atomic fifo enqueue and dequeue
+ * These routines manipulate singly-linked FIFO lists.
+ *
+ * This API is deprecated and no longer recommended
+ */
+
+/*! @abstract The data structure for a fifo queue head.
+    @discussion
+	You should always initialize a fifo queue head structure with the
+	initialization vector {@link OS_ATOMIC_FIFO_QUEUE_INIT} before use.
+ */
+#if defined(__LP64__)
+
+typedef	volatile struct {
+	void	*opaque1;
+	void	*opaque2;
+	int	 opaque3;
+} __attribute__ ((aligned (16))) OSFifoQueueHead;
+
+#else
+
+typedef	volatile struct {
+	void	*opaque1;
+	void	*opaque2;
+	int	 opaque3;
+} OSFifoQueueHead;
+
+#endif
+/*! @abstract The initialization vector for a fifo queue head. */
+#define OS_ATOMIC_FIFO_QUEUE_INIT   { NULL, NULL, 0 }
+
+/*! @abstract Enqueue an element onto a list.
+    @discussion
+	Memory barriers are incorporated as needed to permit thread-safe access
+	to the queue element.
+    @param __list
+	The list on which you want to enqueue the element.
+    @param __new
+	The element to add.
+    @param __offset
+	The "offset" parameter is the offset (in bytes) of the link field
+	from the beginning of the data structure being queued (<code>__new</code>).
+	The link field should be a pointer type.
+	The <code>__offset</code> value needs to be same for all enqueuing and
+	dequeuing operations on the same list, even if different structure types
+	are enqueued on that list.  The use of <code>offsetset()</code>, defined in
+	<code>stddef.h</code> is the common way to specify the <code>__offset</code>
+	value.
+
+	@note
+	This API is deprecated and no longer recommended
+ */
+__API_DEPRECATED("No longer supported", macos(10.7, 11.0))
+void  OSAtomicFifoEnqueue( OSFifoQueueHead *__list, void *__new, size_t __offset);
+
+/*! @abstract Dequeue an element from a list.
+    @discussion
+	Memory barriers are incorporated as needed to permit thread-safe access
+	to the queue element.
+    @param __list
+	The list from which you want to dequeue an element.
+    @param __offset
+	The "offset" parameter is the offset (in bytes) of the link field
+	from the beginning of the data structure being dequeued (<code>__new</code>).
+	The link field should be a pointer type.
+	The <code>__offset</code> value needs to be same for all enqueuing and
+	dequeuing operations on the same list, even if different structure types
+	are enqueued on that list.  The use of <code>offsetset()</code>, defined in
+	<code>stddef.h</code> is the common way to specify the <code>__offset</code>
+	value.
+    @result
+	Returns the oldest enqueued element, or <code>NULL</code> if the
+	list is empty.
+
+	@note
+	This API is deprecated and no longer recommended
+ */
+__API_DEPRECATED("No longer supported", macos(10.7, 11.0))
+void* OSAtomicFifoDequeue( OSFifoQueueHead *__list, size_t __offset);
+
+__END_DECLS
+
+#endif /* TARGET_OS_OSX || TARGET_OS_DRIVERKIT */
+
+#endif /* _OSATOMIC_DEPRECATED_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.13-none/libkern/OSAtomicQueue.h b/lib/libc/include/x86_64-macos.13-none/libkern/OSAtomicQueue.h
new file mode 100644
index 0000000000..66033fc834
--- /dev/null
+++ b/lib/libc/include/x86_64-macos.13-none/libkern/OSAtomicQueue.h
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2004-2016 Apple Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ */
+
+#ifndef _OSATOMICQUEUE_H_
+#define _OSATOMICQUEUE_H_
+
+#include    <stddef.h>
+#include    <sys/cdefs.h>
+#include    <stdint.h>
+#include    <stdbool.h>
+#include    "OSAtomicDeprecated.h"
+
+#include    <Availability.h>
+
+/*! @header Lockless atomic enqueue and dequeue
+ * These routines manipulate singly-linked LIFO lists.
+ */
+
+__BEGIN_DECLS
+
+/*! @abstract The data structure for a queue head.
+    @discussion
+	You should always initialize a queue head structure with the
+	initialization vector {@link OS_ATOMIC_QUEUE_INIT} before use.
+ */
+#if defined(__LP64__)
+
+typedef volatile struct {
+	void	*opaque1;
+	long	 opaque2;
+} __attribute__ ((aligned (16))) OSQueueHead;
+
+#else
+
+typedef volatile struct {
+	void	*opaque1;
+	long	 opaque2;
+} OSQueueHead;
+
+#endif
+
+/*! @abstract The initialization vector for a queue head. */
+#define	OS_ATOMIC_QUEUE_INIT	{ NULL, 0 }
+
+/*! @abstract Enqueue an element onto a list.
+    @discussion
+	Memory barriers are incorporated as needed to permit thread-safe access
+	to the queue element.
+    @param __list
+	The list on which you want to enqueue the element.
+    @param __new
+	The element to add.
+    @param __offset
+	The "offset" parameter is the offset (in bytes) of the link field
+	from the beginning of the data structure being queued (<code>__new</code>).
+	The link field should be a pointer type.
+	The <code>__offset</code> value needs to be same for all enqueuing and
+	dequeuing operations on the same list, even if different structure types
+	are enqueued on that list.  The use of <code>offsetset()</code>, defined in
+	<code>stddef.h</code> is the common way to specify the <code>__offset</code>
+	value.
+ */
+__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_4_0)
+void  OSAtomicEnqueue( OSQueueHead *__list, void *__new, size_t __offset);
+
+
+/*! @abstract Dequeue an element from a list.
+    @discussion
+	Memory barriers are incorporated as needed to permit thread-safe access
+	to the queue element.
+    @param __list
+	The list from which you want to dequeue an element.
+    @param __offset
+	The "offset" parameter is the offset (in bytes) of the link field
+	from the beginning of the data structure being dequeued (<code>__new</code>).
+	The link field should be a pointer type.
+	The <code>__offset</code> value needs to be same for all enqueuing and
+	dequeuing operations on the same list, even if different structure types
+	are enqueued on that list.  The use of <code>offsetset()</code>, defined in
+	<code>stddef.h</code> is the common way to specify the <code>__offset</code>
+	value.
+	IMPORTANT: the memory backing the link field of a queue element must not be
+	unmapped after OSAtomicDequeue() returns until all concurrent calls to
+	OSAtomicDequeue() for the same list on other threads have also returned,
+	as they may still be accessing that memory location.
+    @result
+	Returns the most recently enqueued element, or <code>NULL</code> if the
+	list is empty.
+ */
+__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_4_0)
+void* OSAtomicDequeue( OSQueueHead *__list, size_t __offset);
+
+__END_DECLS
+
+#endif /* _OSATOMICQUEUE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.13-none/libkern/OSSpinLockDeprecated.h b/lib/libc/include/x86_64-macos.13-none/libkern/OSSpinLockDeprecated.h
new file mode 100644
index 0000000000..a654a7bbc2
--- /dev/null
+++ b/lib/libc/include/x86_64-macos.13-none/libkern/OSSpinLockDeprecated.h
@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) 2004-2016 Apple Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ */
+
+#ifndef _OSSPINLOCK_DEPRECATED_H_
+#define _OSSPINLOCK_DEPRECATED_H_
+
+/*! @header
+ * These are deprecated legacy interfaces for userspace spinlocks.
+ *
+ * These interfaces should no longer be used, particularily in situations where
+ * threads of differing priorities may contend on the same spinlock.
+ *
+ * The interfaces in <os/lock.h> should be used instead in cases where a very
+ * low-level lock primitive is required. In general however, using higher level
+ * synchronization primitives such as those provided by the pthread or dispatch
+ * subsystems should be preferred.
+ *
+ * Define OSSPINLOCK_USE_INLINED=1 to get inline implementations of these
+ * interfaces in terms of the <os/lock.h> primitives. This is intended as a
+ * transition convenience, direct use of those primitives is preferred.
+ */
+
+#ifndef OSSPINLOCK_DEPRECATED
+#define OSSPINLOCK_DEPRECATED 1
+#define OSSPINLOCK_DEPRECATED_MSG(_r) "Use " #_r "() from <os/lock.h> instead"
+#define OSSPINLOCK_DEPRECATED_REPLACE_WITH(_r) \
+	__OS_AVAILABILITY_MSG(macosx, deprecated=10.12, OSSPINLOCK_DEPRECATED_MSG(_r)) \
+	__OS_AVAILABILITY_MSG(ios, deprecated=10.0, OSSPINLOCK_DEPRECATED_MSG(_r)) \
+	__OS_AVAILABILITY_MSG(tvos, deprecated=10.0, OSSPINLOCK_DEPRECATED_MSG(_r)) \
+	__OS_AVAILABILITY_MSG(watchos, deprecated=3.0, OSSPINLOCK_DEPRECATED_MSG(_r))
+#else
+#undef OSSPINLOCK_DEPRECATED
+#define OSSPINLOCK_DEPRECATED 0
+#define OSSPINLOCK_DEPRECATED_REPLACE_WITH(_r)
+#endif
+
+#if !(defined(OSSPINLOCK_USE_INLINED) && OSSPINLOCK_USE_INLINED)
+
+#include    <sys/cdefs.h>
+#include    <stddef.h>
+#include    <stdint.h>
+#include    <stdbool.h>
+#include    <Availability.h>
+
+__BEGIN_DECLS
+
+/*! @abstract The default value for an <code>OSSpinLock</code>.
+    @discussion
+	The convention is that unlocked is zero, locked is nonzero.
+ */
+#define	OS_SPINLOCK_INIT    0
+
+
+/*! @abstract Data type for a spinlock.
+    @discussion
+	You should always initialize a spinlock to {@link OS_SPINLOCK_INIT} before
+	using it.
+ */
+typedef int32_t OSSpinLock OSSPINLOCK_DEPRECATED_REPLACE_WITH(os_unfair_lock);
+
+
+/*! @abstract Locks a spinlock if it would not block
+    @result
+	Returns <code>false</code> if the lock was already held by another thread,
+	<code>true</code> if it took the lock successfully.
+ */
+OSSPINLOCK_DEPRECATED_REPLACE_WITH(os_unfair_lock_trylock)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+bool    OSSpinLockTry( volatile OSSpinLock *__lock );
+
+
+/*! @abstract Locks a spinlock
+    @discussion
+	Although the lock operation spins, it employs various strategies to back
+	off if the lock is held.
+ */
+OSSPINLOCK_DEPRECATED_REPLACE_WITH(os_unfair_lock_lock)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+void    OSSpinLockLock( volatile OSSpinLock *__lock );
+
+
+/*! @abstract Unlocks a spinlock */
+OSSPINLOCK_DEPRECATED_REPLACE_WITH(os_unfair_lock_unlock)
+__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0)
+void    OSSpinLockUnlock( volatile OSSpinLock *__lock );
+
+__END_DECLS
+
+#else /* OSSPINLOCK_USE_INLINED */
+
+/*
+ * Inline implementations of the legacy OSSpinLock interfaces in terms of the
+ * of the <os/lock.h> primitives. Direct use of those primitives is preferred.
+ *
+ * NOTE: the locked value of os_unfair_lock is implementation defined and
+ * subject to change, code that relies on the specific locked value used by the
+ * legacy OSSpinLock interface WILL break when using these inline
+ * implementations in terms of os_unfair_lock.
+ */
+
+#if !OSSPINLOCK_USE_INLINED_TRANSPARENT
+
+#include <os/lock.h>
+
+__BEGIN_DECLS
+
+#if __has_attribute(always_inline)
+#define OSSPINLOCK_INLINE static __inline
+#else
+#define OSSPINLOCK_INLINE static __inline __attribute__((__always_inline__))
+#endif
+
+#define OS_SPINLOCK_INIT 0
+typedef int32_t OSSpinLock;
+
+#if  __has_extension(c_static_assert)
+_Static_assert(sizeof(OSSpinLock) == sizeof(os_unfair_lock),
+		"Incompatible os_unfair_lock type");
+#endif
+
+OSSPINLOCK_INLINE
+void
+OSSpinLockLock(volatile OSSpinLock *__lock)
+{
+	os_unfair_lock_t lock = (os_unfair_lock_t)__lock;
+	return os_unfair_lock_lock(lock);
+}
+
+OSSPINLOCK_INLINE
+bool
+OSSpinLockTry(volatile OSSpinLock *__lock)
+{
+	os_unfair_lock_t lock = (os_unfair_lock_t)__lock;
+	return os_unfair_lock_trylock(lock);
+}
+
+OSSPINLOCK_INLINE
+void
+OSSpinLockUnlock(volatile OSSpinLock *__lock)
+{
+	os_unfair_lock_t lock = (os_unfair_lock_t)__lock;
+	return os_unfair_lock_unlock(lock);
+}
+
+#undef OSSPINLOCK_INLINE
+
+__END_DECLS
+
+#else /* OSSPINLOCK_USE_INLINED_TRANSPARENT */
+
+#include    <sys/cdefs.h>
+#include    <stddef.h>
+#include    <stdint.h>
+#include    <stdbool.h>
+#include    <Availability.h>
+
+#define OS_NOSPIN_LOCK_AVAILABILITY \
+		__OSX_AVAILABLE(10.12) __IOS_AVAILABLE(10.0) \
+		__TVOS_AVAILABLE(10.0) __WATCHOS_AVAILABLE(3.0)
+
+__BEGIN_DECLS
+
+#define OS_SPINLOCK_INIT 0
+typedef int32_t OSSpinLock OSSPINLOCK_DEPRECATED_REPLACE_WITH(os_unfair_lock);
+typedef volatile OSSpinLock *_os_nospin_lock_t
+		OSSPINLOCK_DEPRECATED_REPLACE_WITH(os_unfair_lock_t);
+
+OSSPINLOCK_DEPRECATED_REPLACE_WITH(os_unfair_lock_lock)
+OS_NOSPIN_LOCK_AVAILABILITY
+void _os_nospin_lock_lock(_os_nospin_lock_t lock);
+#undef OSSpinLockLock
+#define OSSpinLockLock(lock) _os_nospin_lock_lock(lock)
+
+OSSPINLOCK_DEPRECATED_REPLACE_WITH(os_unfair_lock_trylock)
+OS_NOSPIN_LOCK_AVAILABILITY
+bool _os_nospin_lock_trylock(_os_nospin_lock_t lock);
+#undef OSSpinLockTry
+#define OSSpinLockTry(lock) _os_nospin_lock_trylock(lock)
+
+OSSPINLOCK_DEPRECATED_REPLACE_WITH(os_unfair_lock_unlock)
+OS_NOSPIN_LOCK_AVAILABILITY
+void _os_nospin_lock_unlock(_os_nospin_lock_t lock);
+#undef OSSpinLockUnlock
+#define OSSpinLockUnlock(lock) _os_nospin_lock_unlock(lock)
+
+__END_DECLS
+
+#endif /* OSSPINLOCK_USE_INLINED_TRANSPARENT */
+
+#endif /* OSSPINLOCK_USE_INLINED */
+
+#endif /* _OSSPINLOCK_DEPRECATED_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/libkern/i386/OSByteOrder.h b/lib/libc/include/x86_64-macos.13-none/libkern/i386/OSByteOrder.h
similarity index 100%
rename from lib/libc/include/x86_64-macos.10-none/libkern/i386/OSByteOrder.h
rename to lib/libc/include/x86_64-macos.13-none/libkern/i386/OSByteOrder.h
diff --git a/lib/libc/include/x86_64-macos.10-none/libkern/i386/_OSByteOrder.h b/lib/libc/include/x86_64-macos.13-none/libkern/i386/_OSByteOrder.h
similarity index 100%
rename from lib/libc/include/x86_64-macos.10-none/libkern/i386/_OSByteOrder.h
rename to lib/libc/include/x86_64-macos.13-none/libkern/i386/_OSByteOrder.h
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/i386/_structs.h b/lib/libc/include/x86_64-macos.13-none/mach/i386/_structs.h
similarity index 94%
rename from lib/libc/include/x86_64-macos.10-none/mach/i386/_structs.h
rename to lib/libc/include/x86_64-macos.13-none/mach/i386/_structs.h
index f041af9f3f..02c135184f 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/i386/_structs.h
+++ b/lib/libc/include/x86_64-macos.13-none/mach/i386/_structs.h
@@ -32,6 +32,8 @@
 #ifndef	_MACH_I386__STRUCTS_H_
 #define	_MACH_I386__STRUCTS_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 #include <sys/cdefs.h> /* __DARWIN_UNIX03 */
 #include <machine/types.h> /* __uint8_t */
 
@@ -603,7 +605,48 @@ _STRUCT_X86_DEBUG_STATE32
 	unsigned int	__dr6;
 	unsigned int	__dr7;
 };
+
+#define _STRUCT_X86_INSTRUCTION_STATE	struct __x86_instruction_state
+_STRUCT_X86_INSTRUCTION_STATE
+{
+        int		__insn_stream_valid_bytes;
+        int		__insn_offset;
+	int		__out_of_synch;	/*
+					 * non-zero when the cacheline that includes the insn_offset
+					 * is replaced in the insn_bytes array due to a mismatch
+					 * detected when comparing it with the same cacheline in memory
+					 */
+#define _X86_INSTRUCTION_STATE_MAX_INSN_BYTES    (2448 - 64 - 4)
+        __uint8_t	__insn_bytes[_X86_INSTRUCTION_STATE_MAX_INSN_BYTES];
+#define _X86_INSTRUCTION_STATE_CACHELINE_SIZE	64
+	__uint8_t	__insn_cacheline[_X86_INSTRUCTION_STATE_CACHELINE_SIZE];
+};
+
+#define _STRUCT_LAST_BRANCH_RECORD	struct __last_branch_record
+_STRUCT_LAST_BRANCH_RECORD
+{
+	__uint64_t	__from_ip;
+	__uint64_t	__to_ip;
+	__uint32_t	__mispredict : 1,
+			__tsx_abort  : 1,
+			__in_tsx     : 1,
+			__cycle_count: 16,
+			__reserved   : 13;
+};
+
+#define _STRUCT_LAST_BRANCH_STATE	struct __last_branch_state
+_STRUCT_LAST_BRANCH_STATE
+{
+        int				__lbr_count;
+	__uint32_t			__lbr_supported_tsx : 1,
+					__lbr_supported_cycle_count : 1,
+					__reserved : 30;
+#define	__LASTBRANCH_MAX	32
+	_STRUCT_LAST_BRANCH_RECORD	__lbrs[__LASTBRANCH_MAX];
+};
+
 #else /* !__DARWIN_UNIX03 */
+
 #define _STRUCT_X86_DEBUG_STATE32	struct x86_debug_state32
 _STRUCT_X86_DEBUG_STATE32
 {
@@ -616,6 +659,45 @@ _STRUCT_X86_DEBUG_STATE32
 	unsigned int	dr6;
 	unsigned int	dr7;
 };
+
+#define _STRUCT_X86_INSTRUCTION_STATE	struct __x86_instruction_state
+_STRUCT_X86_INSTRUCTION_STATE
+{
+        int		insn_stream_valid_bytes;
+        int		insn_offset;
+	int		out_of_synch;	/*
+					 * non-zero when the cacheline that includes the insn_offset
+					 * is replaced in the insn_bytes array due to a mismatch
+					 * detected when comparing it with the same cacheline in memory
+					 */
+#define x86_INSTRUCTION_STATE_MAX_INSN_BYTES    (2448 - 64 - 4)
+        __uint8_t	insn_bytes[x86_INSTRUCTION_STATE_MAX_INSN_BYTES];
+#define x86_INSTRUCTION_STATE_CACHELINE_SIZE	64
+	__uint8_t	insn_cacheline[x86_INSTRUCTION_STATE_CACHELINE_SIZE];
+};
+
+#define _STRUCT_LAST_BRANCH_RECORD	struct __last_branch_record
+_STRUCT_LAST_BRANCH_RECORD
+{
+	__uint64_t	from_ip;
+	__uint64_t	to_ip;
+	__uint32_t	mispredict : 1,
+			tsx_abort  : 1,
+			in_tsx     : 1,
+			cycle_count: 16,
+			reserved   : 13;
+};
+
+#define _STRUCT_LAST_BRANCH_STATE	struct __last_branch_state
+_STRUCT_LAST_BRANCH_STATE
+{
+        int				lbr_count;
+	__uint32_t			lbr_supported_tsx : 1,
+					lbr_supported_cycle_count : 1,
+					reserved : 30;
+#define	__LASTBRANCH_MAX	32
+	_STRUCT_LAST_BRANCH_RECORD	lbrs[__LASTBRANCH_MAX];
+};
 #endif /* !__DARWIN_UNIX03 */
 
 #define	_STRUCT_X86_PAGEIN_STATE	struct __x86_pagein_state
@@ -1229,4 +1311,6 @@ _STRUCT_X86_CPMU_STATE64
 };
 #endif /* !__DARWIN_UNIX03 */
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif /* _MACH_I386__STRUCTS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/i386/boolean.h b/lib/libc/include/x86_64-macos.13-none/mach/i386/boolean.h
similarity index 96%
rename from lib/libc/include/x86_64-macos.10-none/mach/i386/boolean.h
rename to lib/libc/include/x86_64-macos.13-none/mach/i386/boolean.h
index d604dfcea2..b1d69a193b 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/i386/boolean.h
+++ b/lib/libc/include/x86_64-macos.13-none/mach/i386/boolean.h
@@ -65,10 +65,14 @@
 #ifndef _MACH_I386_BOOLEAN_H_
 #define _MACH_I386_BOOLEAN_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 #if defined(__x86_64__) && !defined(KERNEL)
 typedef unsigned int    boolean_t;
 #else
 typedef int             boolean_t;
 #endif
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif  /* _MACH_I386_BOOLEAN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/i386/exception.h b/lib/libc/include/x86_64-macos.13-none/mach/i386/exception.h
similarity index 97%
rename from lib/libc/include/x86_64-macos.10-none/mach/i386/exception.h
rename to lib/libc/include/x86_64-macos.13-none/mach/i386/exception.h
index 3f21c3d4e6..1a8b2c0d1d 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/i386/exception.h
+++ b/lib/libc/include/x86_64-macos.13-none/mach/i386/exception.h
@@ -59,6 +59,8 @@
 #ifndef _MACH_I386_EXCEPTION_H_
 #define _MACH_I386_EXCEPTION_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 /*
  * No machine dependent types for the 80386
  */
@@ -132,4 +134,6 @@
  */
 #define EXC_MASK_MACHINE        0
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif  /* _MACH_I386_EXCEPTION_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/i386/fp_reg.h b/lib/libc/include/x86_64-macos.13-none/mach/i386/fp_reg.h
similarity index 98%
rename from lib/libc/include/x86_64-macos.10-none/mach/i386/fp_reg.h
rename to lib/libc/include/x86_64-macos.13-none/mach/i386/fp_reg.h
index eb010ad950..e968978842 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/i386/fp_reg.h
+++ b/lib/libc/include/x86_64-macos.13-none/mach/i386/fp_reg.h
@@ -59,6 +59,8 @@
 #ifndef _I386_FP_SAVE_H_
 #define _I386_FP_SAVE_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 /*
  * Control register
  */
@@ -115,4 +117,6 @@
 #define FP_387          3               /* 80387 or 80486 */
 #define FP_FXSR         4               /* Fast save/restore SIMD Extension */
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif  /* _I386_FP_SAVE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/i386/kern_return.h b/lib/libc/include/x86_64-macos.13-none/mach/i386/kern_return.h
similarity index 96%
rename from lib/libc/include/x86_64-macos.10-none/mach/i386/kern_return.h
rename to lib/libc/include/x86_64-macos.13-none/mach/i386/kern_return.h
index 47aa4b8753..3a12665ead 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/i386/kern_return.h
+++ b/lib/libc/include/x86_64-macos.13-none/mach/i386/kern_return.h
@@ -67,8 +67,12 @@
 #ifndef _MACH_I386_KERN_RETURN_H_
 #define _MACH_I386_KERN_RETURN_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 #ifndef ASSEMBLER
 typedef int             kern_return_t;
 #endif  /* ASSEMBLER */
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif  /* _MACH_I386_KERN_RETURN_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/i386/processor_info.h b/lib/libc/include/x86_64-macos.13-none/mach/i386/processor_info.h
similarity index 93%
rename from lib/libc/include/x86_64-macos.10-none/mach/i386/processor_info.h
rename to lib/libc/include/x86_64-macos.13-none/mach/i386/processor_info.h
index 4426e0041c..5a9aeac9cb 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/i386/processor_info.h
+++ b/lib/libc/include/x86_64-macos.13-none/mach/i386/processor_info.h
@@ -34,4 +34,8 @@
 #ifndef _MACH_I386_PROCESSOR_INFO_H_
 #define _MACH_I386_PROCESSOR_INFO_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif  /* _MACH_I386_PROCESSOR_INFO_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/i386/rpc.h b/lib/libc/include/x86_64-macos.13-none/mach/i386/rpc.h
similarity index 93%
rename from lib/libc/include/x86_64-macos.10-none/mach/i386/rpc.h
rename to lib/libc/include/x86_64-macos.13-none/mach/i386/rpc.h
index 0298ebb804..fcd2829f6b 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/i386/rpc.h
+++ b/lib/libc/include/x86_64-macos.13-none/mach/i386/rpc.h
@@ -32,4 +32,8 @@
 #ifndef _MACH_I386_RPC_H_
 #define _MACH_I386_RPC_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif  /* _MACH_I386_RPC_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/i386/thread_state.h b/lib/libc/include/x86_64-macos.13-none/mach/i386/thread_state.h
similarity index 90%
rename from lib/libc/include/x86_64-macos.10-none/mach/i386/thread_state.h
rename to lib/libc/include/x86_64-macos.13-none/mach/i386/thread_state.h
index 78595255a3..421917aeb3 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/i386/thread_state.h
+++ b/lib/libc/include/x86_64-macos.13-none/mach/i386/thread_state.h
@@ -32,11 +32,11 @@
 #ifndef _MACH_I386_THREAD_STATE_H_
 #define _MACH_I386_THREAD_STATE_H_
 
-/* Size of maximum exported thread state in words */
+#if defined (__i386__) || defined (__x86_64__)
+
+/* Size of maximum exported thread state in 32-bit words */
 #define I386_THREAD_STATE_MAX   (614)    /* Size of biggest state possible */
 
-#if defined (__i386__) || defined(__x86_64__)
-#define THREAD_STATE_MAX        I386_THREAD_STATE_MAX
-#endif
+#endif /* defined (__i386__) || defined (__x86_64__) */
 
 #endif  /* _MACH_I386_THREAD_STATE_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/i386/thread_status.h b/lib/libc/include/x86_64-macos.13-none/mach/i386/thread_status.h
similarity index 93%
rename from lib/libc/include/x86_64-macos.10-none/mach/i386/thread_status.h
rename to lib/libc/include/x86_64-macos.13-none/mach/i386/thread_status.h
index 233e0f22a6..d401a11fd0 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/i386/thread_status.h
+++ b/lib/libc/include/x86_64-macos.13-none/mach/i386/thread_status.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2020 Apple Computer, Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  *
@@ -67,10 +67,12 @@
 #ifndef _MACH_I386_THREAD_STATUS_H_
 #define _MACH_I386_THREAD_STATUS_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 #include <mach/machine/_structs.h>
+#include <mach/machine/thread_state.h>
 #include <mach/message.h>
 #include <mach/i386/fp_reg.h>
-#include <mach/i386/thread_state.h>
 #include <i386/eflags.h>
 
 
@@ -121,6 +123,8 @@
 #define x86_AVX512_STATE                (x86_AVX512_STATE32 + 2)
 #define x86_PAGEIN_STATE                22
 #define x86_THREAD_FULL_STATE64         23
+#define x86_INSTRUCTION_STATE           24
+#define x86_LAST_BRANCH_STATE           25
 
 /*
  * Largest state on this machine:
@@ -155,6 +159,8 @@
 	  (x == x86_AVX512_STATE64)		|| \
 	  (x == x86_AVX512_STATE)		|| \
 	  (x == x86_PAGEIN_STATE)		|| \
+	  (x == x86_INSTRUCTION_STATE)		|| \
+	  (x == x86_LAST_BRANCH_STATE)		|| \
 	  (x == THREAD_STATE_NONE))
 
 struct x86_state_hdr {
@@ -259,6 +265,19 @@ typedef _STRUCT_X86_PAGEIN_STATE x86_pagein_state_t;
 
 #define X86_PAGEIN_STATE_COUNT x86_PAGEIN_STATE_COUNT
 
+typedef _STRUCT_X86_INSTRUCTION_STATE x86_instruction_state_t;
+#define x86_INSTRUCTION_STATE_COUNT \
+    ((mach_msg_type_number_t)(sizeof(x86_instruction_state_t) / sizeof(int)))
+
+#define X86_INSTRUCTION_STATE_COUNT x86_INSTRUCTION_STATE_COUNT
+
+typedef _STRUCT_LAST_BRANCH_STATE last_branch_state_t;
+#define x86_LAST_BRANCH_STATE_COUNT \
+    ((mach_msg_type_number_t)(sizeof(last_branch_state_t) / sizeof(int)))
+
+#define X86_LAST_BRANCH_STATE_COUNT x86_LAST_BRANCH_STATE_COUNT
+
+
 /*
  * Combined thread, float and exception states
  */
@@ -342,4 +361,6 @@ typedef struct x86_avx512_state x86_avx512_state_t;
 #define MACHINE_THREAD_STATE_COUNT      x86_THREAD_STATE_COUNT
 
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif  /* _MACH_I386_THREAD_STATUS_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/i386/vm_param.h b/lib/libc/include/x86_64-macos.13-none/mach/i386/vm_param.h
similarity index 80%
rename from lib/libc/include/x86_64-macos.10-none/mach/i386/vm_param.h
rename to lib/libc/include/x86_64-macos.13-none/mach/i386/vm_param.h
index a85ee924b7..953f4a1605 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/i386/vm_param.h
+++ b/lib/libc/include/x86_64-macos.13-none/mach/i386/vm_param.h
@@ -90,54 +90,45 @@
 #ifndef _MACH_I386_VM_PARAM_H_
 #define _MACH_I386_VM_PARAM_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
+#if !defined(KERNEL) && !defined(__ASSEMBLER__)
+
+#include <mach/vm_page_size.h>
+#endif
+
 #define BYTE_SIZE               8               /* byte size in bits */
 
 #define I386_PGBYTES            4096            /* bytes per 80386 page */
 #define I386_PGSHIFT            12              /* bitshift for pages */
 
-#define PAGE_SIZE               I386_PGBYTES
+
+#if !defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || (__MAC_OS_X_VERSION_MIN_REQUIRED < 101600)
 #define PAGE_SHIFT              I386_PGSHIFT
-#define PAGE_MASK               (PAGE_SIZE - 1)
+#define PAGE_SIZE               I386_PGBYTES
+#define PAGE_MASK               (PAGE_SIZE-1)
+#else /* !defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || (__MAC_OS_X_VERSION_MIN_REQUIRED < 101600) */
+#define PAGE_SHIFT              vm_page_shift
+#define PAGE_SIZE               vm_page_size
+#define PAGE_MASK               vm_page_mask
+#endif /* !defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || (__MAC_OS_X_VERSION_MIN_REQUIRED < 101600) */
 
-#define PAGE_MAX_SHIFT          PAGE_SHIFT
-#define PAGE_MAX_SIZE           PAGE_SIZE
-#define PAGE_MAX_MASK           PAGE_MASK
-
-#define PAGE_MIN_SHIFT          PAGE_SHIFT
-#define PAGE_MIN_SIZE           PAGE_SIZE
-#define PAGE_MIN_MASK           PAGE_MASK
-
-#define I386_LPGBYTES           2*1024*1024     /* bytes per large page */
-#define I386_LPGSHIFT           21              /* bitshift for large pages */
-#define I386_LPGMASK            (I386_LPGBYTES-1)
-
-/*
- *	Convert bytes to pages and convert pages to bytes.
- *	No rounding is used.
- */
-
-#define i386_btop(x)            ((ppnum_t)((x) >> I386_PGSHIFT))
-#define machine_btop(x)         i386_btop(x)
-#define i386_ptob(x)            (((pmap_paddr_t)(x)) << I386_PGSHIFT)
-#define machine_ptob(x)         i386_ptob(x)
-
-/*
- *	Round off or truncate to the nearest page.  These will work
- *	for either addresses or counts.  (i.e. 1 byte rounds to 1 page
- *	bytes.
- */
-
-#define i386_round_page(x)      ((((pmap_paddr_t)(x)) + I386_PGBYTES - 1) & \
-	                                ~(I386_PGBYTES-1))
-#define i386_trunc_page(x)      (((pmap_paddr_t)(x)) & ~(I386_PGBYTES-1))
+#define PAGE_MAX_SHIFT          14
+#define PAGE_MAX_SIZE           (1 << PAGE_MAX_SHIFT)
+#define PAGE_MAX_MASK           (PAGE_MAX_SIZE-1)
 
+#define PAGE_MIN_SHIFT          12
+#define PAGE_MIN_SIZE           (1 << PAGE_MIN_SHIFT)
+#define PAGE_MIN_MASK           (PAGE_MIN_SIZE-1)
 
 
 #define VM_MIN_ADDRESS64        ((user_addr_t) 0x0000000000000000ULL)
 /*
- * default top of user stack... it grows down from here
+ * Default top of user stack, grows down from here.
+ * Address chosen to be 1G (3rd level page table entry) below SHARED_REGION_BASE_X86_64
+ * minus additional 1Meg (1/2 1st level page table coverage) to allow a redzone after it.
  */
-#define VM_USRSTACK64           ((user_addr_t) 0x00007FFEEFC00000ULL)
+#define VM_USRSTACK64           ((user_addr_t) (0x00007FF7C0000000ull - (1024 * 1024)))
 
 /*
  * XXX TODO: Obsolete?
@@ -167,4 +158,6 @@
 
 
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif  /* _MACH_I386_VM_PARAM_H_ */
\ No newline at end of file
diff --git a/lib/libc/include/x86_64-macos.10-none/mach/i386/vm_types.h b/lib/libc/include/x86_64-macos.13-none/mach/i386/vm_types.h
similarity index 89%
rename from lib/libc/include/x86_64-macos.10-none/mach/i386/vm_types.h
rename to lib/libc/include/x86_64-macos.13-none/mach/i386/vm_types.h
index 8a95db53ee..f3e956d3e2 100644
--- a/lib/libc/include/x86_64-macos.10-none/mach/i386/vm_types.h
+++ b/lib/libc/include/x86_64-macos.13-none/mach/i386/vm_types.h
@@ -67,11 +67,13 @@
 #ifndef _MACH_I386_VM_TYPES_H_
 #define _MACH_I386_VM_TYPES_H_
 
+#if defined (__i386__) || defined (__x86_64__)
+
 #ifndef ASSEMBLER
 
 #include <i386/_types.h>
-#include <mach/i386/vm_param.h>
 #include <stdint.h>
+#include <sys/cdefs.h>
 
 /*
  * natural_t and integer_t are Mach's legacy types for machine-
@@ -98,9 +100,9 @@ typedef int                     integer_t;
  * e.g. an offset into a virtual memory space.
  */
 #ifdef __LP64__
-typedef uintptr_t               vm_offset_t;
+typedef uintptr_t               vm_offset_t __kernel_ptr_semantics;
 #else   /* __LP64__ */
-typedef natural_t               vm_offset_t;
+typedef natural_t               vm_offset_t __kernel_ptr_semantics;
 #endif  /* __LP64__ */
 
 /*
@@ -121,12 +123,12 @@ typedef natural_t               vm_size_t;
  * where the size of the map is not known - or we don't
  * want to have to distinguish.
  */
-typedef uint64_t                mach_vm_address_t;
-typedef uint64_t                mach_vm_offset_t;
+typedef uint64_t                mach_vm_address_t __kernel_ptr_semantics;
+typedef uint64_t                mach_vm_offset_t __kernel_ptr_semantics;
 typedef uint64_t                mach_vm_size_t;
 
-typedef uint64_t                vm_map_offset_t;
-typedef uint64_t                vm_map_address_t;
+typedef uint64_t                vm_map_offset_t __kernel_ptr_semantics;
+typedef uint64_t                vm_map_address_t __kernel_ptr_semantics;
 typedef uint64_t                vm_map_size_t;
 
 typedef mach_vm_address_t       mach_port_context_t;
@@ -139,4 +141,6 @@ typedef mach_vm_address_t       mach_port_context_t;
  */
 #define MACH_MSG_TYPE_INTEGER_T MACH_MSG_TYPE_INTEGER_32
 
+#endif /* defined (__i386__) || defined (__x86_64__) */
+
 #endif  /* _MACH_I386_VM_TYPES_H_ */
\ No newline at end of file

From 85b669d497641de383070353d50a6e4fd30abd49 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Wed, 19 Oct 2022 21:48:21 +0200
Subject: [PATCH 13/70] wasm-linker: validate feature compatibility

Verifies disallowed and used/required features. After verifying,
all errors will be emit to notify the user about incompatible
features. When the user did not define any featureset, we infer
the features from the linked objects instead.
---
 src/link/Wasm.zig       | 107 ++++++++++++++++++++++++++++++++++++++++
 src/link/Wasm/types.zig |  24 ++++-----
 2 files changed, 117 insertions(+), 14 deletions(-)

diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 4c3de84e01..ed07756345 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -651,6 +651,112 @@ fn resolveSymbolsInArchives(wasm: *Wasm) !void {
     }
 }
 
+fn validateFeatures(wasm: *const Wasm, arena: Allocator) !void {
+    const cpu_features = wasm.base.options.target.cpu.features;
+    const infer = cpu_features.isEmpty(); // when the user did not define any features, we infer them from linked objects.
+    var allowed = std.AutoHashMap(std.Target.wasm.Feature, void).init(arena);
+    var used = std.AutoArrayHashMap(std.Target.wasm.Feature, []const u8).init(arena);
+    var disallowed = std.AutoHashMap(std.Target.wasm.Feature, []const u8).init(arena);
+    var required = std.AutoHashMap(std.Target.wasm.Feature, []const u8).init(arena);
+
+    // when false, we fail linking. We only verify this after a loop to catch all invalid features.
+    var valid_feature_set = true;
+
+    // When the user has given an explicit list of features to enable,
+    // we extract them and insert each into the 'allowed' list.
+    if (!infer) {
+        try allowed.ensureUnusedCapacity(std.Target.wasm.all_features.len);
+        // std.builtin.Type.EnumField
+        inline for (@typeInfo(std.Target.wasm.Feature).Enum.fields) |feature_field| {
+            if (cpu_features.isEnabled(feature_field.value)) {
+                allowed.putAssumeCapacityNoClobber(@intToEnum(std.Target.wasm.Feature, feature_field.value), {});
+            }
+        }
+    }
+
+    // extract all the used, disallowed and required features from each
+    // linked object file so we can test them.
+    for (wasm.objects.items) |object| {
+        for (object.features) |feature| {
+            switch (feature.prefix) {
+                .used => {
+                    const gop = try used.getOrPut(feature.tag);
+                    if (!gop.found_existing) {
+                        gop.value_ptr.* = object.name;
+                    }
+                },
+                .disallowed => {
+                    const gop = try disallowed.getOrPut(feature.tag);
+                    if (!gop.found_existing) {
+                        gop.value_ptr.* = object.name;
+                    }
+                },
+                .required => {
+                    const gop = try required.getOrPut(feature.tag);
+                    if (!gop.found_existing) {
+                        gop.value_ptr.* = object.name;
+                    }
+                    const used_gop = try used.getOrPut(feature.tag);
+                    if (!used_gop.found_existing) {
+                        used_gop.value_ptr.* = object.name;
+                    }
+                },
+            }
+        }
+    }
+
+    // when we infer the features, we allow each feature found in the 'used' set
+    // and insert it into the 'allowed' set. When features are not inferred,
+    // we validate that a used feature is allowed.
+    if (infer) try allowed.ensureUnusedCapacity(@intCast(u32, used.count()));
+    for (used.keys()) |used_feature, used_index| {
+        if (infer) {
+            allowed.putAssumeCapacityNoClobber(used_feature, {});
+        } else if (!allowed.contains(used_feature)) {
+            log.err("feature '{s}' not allowed, but used by linked object", .{@tagName(used_feature)});
+            log.err("  defined in '{s}'", .{used.values()[used_index]});
+            valid_feature_set = false;
+        }
+    }
+
+    if (!valid_feature_set) {
+        return error.InvalidFeatureSet;
+    }
+
+    // For each linked object, validate the required and disallowed features
+    for (wasm.objects.items) |object| {
+        var object_used_features = std.AutoHashMap(std.Target.wasm.Feature, void).init(arena);
+        try object_used_features.ensureTotalCapacity(@intCast(u32, object.features.len));
+        for (object.features) |feature| {
+            if (feature.prefix == .disallowed) continue; // already defined in 'disallowed' set.
+            // from here a feature is always used
+            if (disallowed.get(feature.tag)) |disallowed_object_name| {
+                log.err("feature '{s}' is disallowed, but used by linked object", .{@tagName(feature.tag)});
+                log.err("  disallowed by '{s}'", .{disallowed_object_name});
+                log.err("  used in '{s}'", .{object.name});
+                valid_feature_set = false;
+            }
+
+            object_used_features.putAssumeCapacity(feature.tag, {});
+        }
+
+        // validate the linked object file has each required feature
+        var required_it = required.iterator();
+        while (required_it.next()) |required_feature| {
+            if (!object_used_features.contains(required_feature.key_ptr.*)) {
+                log.err("feature '{s}' is required but not used in linked object", .{@tagName(required_feature.key_ptr.*)});
+                log.err("  required by '{s}'", .{required_feature.value_ptr.*});
+                log.err("  missing in '{s}'", .{object.name});
+                valid_feature_set = false;
+            }
+        }
+    }
+
+    if (!valid_feature_set) {
+        return error.InvalidFeatureSet;
+    }
+}
+
 fn checkUndefinedSymbols(wasm: *const Wasm) !void {
     if (wasm.base.options.output_mode == .Obj) return;
 
@@ -2158,6 +2264,7 @@ pub fn flushModule(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Nod
         try wasm.resolveSymbolsInObject(@intCast(u16, object_index));
     }
 
+    try wasm.validateFeatures(arena);
     try wasm.resolveSymbolsInArchives();
     try wasm.checkUndefinedSymbols();
 
diff --git a/src/link/Wasm/types.zig b/src/link/Wasm/types.zig
index 2006fe1812..5e071c2f20 100644
--- a/src/link/Wasm/types.zig
+++ b/src/link/Wasm/types.zig
@@ -183,18 +183,7 @@ pub const Feature = struct {
     /// Type of the feature, must be unique in the sequence of features.
     tag: Tag,
 
-    pub const Tag = enum {
-        atomics,
-        bulk_memory,
-        exception_handling,
-        multivalue,
-        mutable_globals,
-        nontrapping_fptoint,
-        sign_ext,
-        simd128,
-        tail_call,
-        shared_mem,
-    };
+    pub const Tag = std.Target.wasm.Feature;
 
     pub const Prefix = enum(u8) {
         used = '+',
@@ -204,13 +193,18 @@ pub const Feature = struct {
 
     pub fn toString(feature: Feature) []const u8 {
         return switch (feature.tag) {
+            .atomics => "atomics",
             .bulk_memory => "bulk-memory",
             .exception_handling => "exception-handling",
+            .extended_const => "extended-const",
+            .multivalue => "multivalue",
             .mutable_globals => "mutable-globals",
             .nontrapping_fptoint => "nontrapping-fptoint",
+            .reference_types => "reference-types",
+            .relaxed_simd => "relaxed-simd",
             .sign_ext => "sign-ext",
+            .simd128 => "simd128",
             .tail_call => "tail-call",
-            else => @tagName(feature),
         };
     }
 
@@ -225,11 +219,13 @@ pub const known_features = std.ComptimeStringMap(Feature.Tag, .{
     .{ "atomics", .atomics },
     .{ "bulk-memory", .bulk_memory },
     .{ "exception-handling", .exception_handling },
+    .{ "extended-const", .extended_const },
     .{ "multivalue", .multivalue },
     .{ "mutable-globals", .mutable_globals },
     .{ "nontrapping-fptoint", .nontrapping_fptoint },
+    .{ "reference-types", .reference_types },
+    .{ "relaxed-simd", .relaxed_simd },
     .{ "sign-ext", .sign_ext },
     .{ "simd128", .simd128 },
     .{ "tail-call", .tail_call },
-    .{ "shared-mem", .shared_mem },
 });

From 777bcbf96871a0250664b9cabdea5dbf51e0e64d Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Thu, 20 Oct 2022 16:58:00 +0200
Subject: [PATCH 14/70] wasm-linker: emit `target_features` section

When the result is not being stripped, we emit the `target_features`
section based on all the used features. This includes features
inferred from linked object files.
Considering we know all possible features upfront, we can use an
array and therefore do not have to dynamically allocate memory.
Using this trick we can also easily order all features based
the same ordering as found in `std.Target.wasm` which is the same
ordering used by LLVM and the like.
---
 src/link/Wasm.zig | 47 +++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 45 insertions(+), 2 deletions(-)

diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index ed07756345..da9a878720 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -651,7 +651,12 @@ fn resolveSymbolsInArchives(wasm: *Wasm) !void {
     }
 }
 
-fn validateFeatures(wasm: *const Wasm, arena: Allocator) !void {
+fn validateFeatures(
+    wasm: *const Wasm,
+    arena: Allocator,
+    to_emit: *[@typeInfo(std.Target.wasm.Feature).Enum.fields.len]bool,
+    emit_features_count: *u32,
+) !void {
     const cpu_features = wasm.base.options.target.cpu.features;
     const infer = cpu_features.isEmpty(); // when the user did not define any features, we infer them from linked objects.
     var allowed = std.AutoHashMap(std.Target.wasm.Feature, void).init(arena);
@@ -755,6 +760,13 @@ fn validateFeatures(wasm: *const Wasm, arena: Allocator) !void {
     if (!valid_feature_set) {
         return error.InvalidFeatureSet;
     }
+
+    if (allowed.count() > 0) {
+        emit_features_count.* = allowed.count();
+        for (to_emit) |*feature_enabled, feature_index| {
+            feature_enabled.* = allowed.contains(@intToEnum(std.Target.wasm.Feature, feature_index));
+        }
+    }
 }
 
 fn checkUndefinedSymbols(wasm: *const Wasm) !void {
@@ -2264,7 +2276,9 @@ pub fn flushModule(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Nod
         try wasm.resolveSymbolsInObject(@intCast(u16, object_index));
     }
 
-    try wasm.validateFeatures(arena);
+    var emit_features_count: u32 = 0;
+    var enabled_features: [@typeInfo(std.Target.wasm.Feature).Enum.fields.len]bool = undefined;
+    try wasm.validateFeatures(arena, &enabled_features, &emit_features_count);
     try wasm.resolveSymbolsInArchives();
     try wasm.checkUndefinedSymbols();
 
@@ -2710,6 +2724,9 @@ pub fn flushModule(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Nod
         }
 
         try emitProducerSection(&binary_bytes);
+        if (emit_features_count > 0) {
+            try emitFeaturesSection(&binary_bytes, &enabled_features, emit_features_count);
+        }
     }
 
     // Only when writing all sections executed properly we write the magic
@@ -2802,6 +2819,32 @@ fn emitProducerSection(binary_bytes: *std.ArrayList(u8)) !void {
     );
 }
 
+fn emitFeaturesSection(binary_bytes: *std.ArrayList(u8), enabled_features: []const bool, features_count: u32) !void {
+    const header_offset = try reserveCustomSectionHeader(binary_bytes);
+
+    const writer = binary_bytes.writer();
+    const target_features = "target_features";
+    try leb.writeULEB128(writer, @intCast(u32, target_features.len));
+    try writer.writeAll(target_features);
+
+    try leb.writeULEB128(writer, features_count);
+    for (enabled_features) |enabled, feature_index| {
+        if (enabled) {
+            const feature: types.Feature = .{ .prefix = .used, .tag = @intToEnum(types.Feature.Tag, feature_index) };
+            try leb.writeULEB128(writer, @enumToInt(feature.prefix));
+            const string = feature.toString();
+            try leb.writeULEB128(writer, @intCast(u32, string.len));
+            try writer.writeAll(string);
+        }
+    }
+
+    try writeCustomSectionHeader(
+        binary_bytes.items,
+        header_offset,
+        @intCast(u32, binary_bytes.items.len - header_offset - 6),
+    );
+}
+
 fn emitNameSection(wasm: *Wasm, binary_bytes: *std.ArrayList(u8), arena: std.mem.Allocator) !void {
     const Name = struct {
         index: u32,

From b14f605dd7b808d1e6d3ee1f8d545135ebe296ee Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Sun, 23 Oct 2022 19:20:18 +0200
Subject: [PATCH 15/70] CheckObjectStep: parse and dump `target_features`

When an object file or binary contains the target_features section
we can now parse and then dump its contents in string format so
we can use them in our linker tests to verify the features section.
---
 lib/std/build/CheckObjectStep.zig | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/lib/std/build/CheckObjectStep.zig b/lib/std/build/CheckObjectStep.zig
index 315bbd9b03..63b361473b 100644
--- a/lib/std/build/CheckObjectStep.zig
+++ b/lib/std/build/CheckObjectStep.zig
@@ -649,6 +649,8 @@ const WasmDumper = struct {
                     try parseDumpNames(reader, writer, data);
                 } else if (mem.eql(u8, name, "producers")) {
                     try parseDumpProducers(reader, writer, data);
+                } else if (mem.eql(u8, name, "target_features")) {
+                    try parseDumpFeatures(reader, writer, data);
                 }
                 // TODO: Implement parsing and dumping other custom sections (such as relocations)
             },
@@ -902,4 +904,19 @@ const WasmDumper = struct {
             }
         }
     }
+
+    fn parseDumpFeatures(reader: anytype, writer: anytype, data: []const u8) !void {
+        const feature_count = try std.leb.readULEB128(u32, reader);
+        try writer.print("features {d}\n", .{feature_count});
+
+        var index: u32 = 0;
+        while (index < feature_count) : (index += 1) {
+            const prefix_byte = try std.leb.readULEB128(u8, reader);
+            const name_length = try std.leb.readULEB128(u32, reader);
+            const feature_name = data[reader.context.pos..][0..name_length];
+            reader.context.pos += name_length;
+
+            try writer.print("{c} {s}\n", .{ prefix_byte, feature_name });
+        }
+    }
 };

From 2f41109cc445c450029ea81c0da6873f32fa0981 Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Sun, 23 Oct 2022 20:00:27 +0200
Subject: [PATCH 16/70] test/link: add Wasm linker tests for features

Adds a test for inferring features based on a different object file.
Also provides a test case where cpu features are explicitly set on
a library where the end result will output said target features.
---
 test/link.zig                           |  8 ++++++
 test/link/wasm/basic-features/build.zig | 23 +++++++++++++++
 test/link/wasm/basic-features/main.zig  |  1 +
 test/link/wasm/infer-features/build.zig | 37 +++++++++++++++++++++++++
 test/link/wasm/infer-features/foo.c     |  3 ++
 test/link/wasm/infer-features/main.zig  |  1 +
 6 files changed, 73 insertions(+)
 create mode 100644 test/link/wasm/basic-features/build.zig
 create mode 100644 test/link/wasm/basic-features/main.zig
 create mode 100644 test/link/wasm/infer-features/build.zig
 create mode 100644 test/link/wasm/infer-features/foo.c
 create mode 100644 test/link/wasm/infer-features/main.zig

diff --git a/test/link.zig b/test/link.zig
index df397cd5d2..40635b86a0 100644
--- a/test/link.zig
+++ b/test/link.zig
@@ -33,6 +33,10 @@ fn addWasmCases(cases: *tests.StandaloneContext) void {
         .requires_stage2 = true,
     });
 
+    cases.addBuildFile("test/link/wasm/basic-features/build.zig", .{
+        .requires_stage2 = true,
+    });
+
     cases.addBuildFile("test/link/wasm/bss/build.zig", .{
         .build_modes = false,
         .requires_stage2 = true,
@@ -44,6 +48,10 @@ fn addWasmCases(cases: *tests.StandaloneContext) void {
         .use_emulation = true,
     });
 
+    cases.addBuildFile("test/link/wasm/infer-features/build.zig", .{
+        .requires_stage2 = true,
+    });
+
     cases.addBuildFile("test/link/wasm/producers/build.zig", .{
         .build_modes = true,
         .requires_stage2 = true,
diff --git a/test/link/wasm/basic-features/build.zig b/test/link/wasm/basic-features/build.zig
new file mode 100644
index 0000000000..2c565f9263
--- /dev/null
+++ b/test/link/wasm/basic-features/build.zig
@@ -0,0 +1,23 @@
+const std = @import("std");
+
+pub fn build(b: *std.build.Builder) void {
+    const mode = b.standardReleaseOptions();
+
+    // Library with explicitly set cpu features
+    const lib = b.addSharedLibrary("lib", "main.zig", .unversioned);
+    lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    lib.target.cpu_model = .{ .explicit = &std.Target.wasm.cpu.mvp };
+    lib.target.cpu_features_add.addFeature(0); // index 0 == atomics (see std.Target.wasm.Features)
+    lib.setBuildMode(mode);
+    lib.use_llvm = false;
+    lib.use_lld = false;
+
+    // Verify the result contains the features explicitly set on the target for the library.
+    const check = lib.checkObject(.wasm);
+    check.checkStart("name target_features");
+    check.checkNext("features 1");
+    check.checkNext("+ atomics");
+
+    const test_step = b.step("test", "Run linker test");
+    test_step.dependOn(&check.step);
+}
diff --git a/test/link/wasm/basic-features/main.zig b/test/link/wasm/basic-features/main.zig
new file mode 100644
index 0000000000..0e416dbf18
--- /dev/null
+++ b/test/link/wasm/basic-features/main.zig
@@ -0,0 +1 @@
+export fn foo() void {}
diff --git a/test/link/wasm/infer-features/build.zig b/test/link/wasm/infer-features/build.zig
new file mode 100644
index 0000000000..b50caf7264
--- /dev/null
+++ b/test/link/wasm/infer-features/build.zig
@@ -0,0 +1,37 @@
+const std = @import("std");
+
+pub fn build(b: *std.build.Builder) void {
+    const mode = b.standardReleaseOptions();
+
+    // Wasm Object file which we will use to infer the features from
+    const c_obj = b.addObject("c_obj", null);
+    c_obj.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    c_obj.target.cpu_model = .{ .explicit = &std.Target.wasm.cpu.bleeding_edge };
+    c_obj.addCSourceFile("foo.c", &.{});
+    c_obj.setBuildMode(mode);
+
+    // Wasm library that doesn't have any features specified. This will
+    // infer its featureset from other linked object files.
+    const lib = b.addSharedLibrary("lib", "main.zig", .unversioned);
+    lib.setTarget(.{ .cpu_arch = .wasm32, .os_tag = .freestanding });
+    lib.target.cpu_model = .{ .explicit = &std.Target.wasm.cpu.mvp };
+    lib.setBuildMode(mode);
+    lib.use_llvm = false;
+    lib.use_lld = false;
+    lib.addObject(c_obj);
+
+    // Verify the result contains the features from the C Object file.
+    const check = lib.checkObject(.wasm);
+    check.checkStart("name target_features");
+    check.checkNext("features 7");
+    check.checkNext("+ atomics");
+    check.checkNext("+ bulk-memory");
+    check.checkNext("+ mutable-globals");
+    check.checkNext("+ nontrapping-fptoint");
+    check.checkNext("+ sign-ext");
+    check.checkNext("+ simd128");
+    check.checkNext("+ tail-call");
+
+    const test_step = b.step("test", "Run linker test");
+    test_step.dependOn(&check.step);
+}
diff --git a/test/link/wasm/infer-features/foo.c b/test/link/wasm/infer-features/foo.c
new file mode 100644
index 0000000000..1faba96983
--- /dev/null
+++ b/test/link/wasm/infer-features/foo.c
@@ -0,0 +1,3 @@
+int foo() {
+  return 5;
+}
diff --git a/test/link/wasm/infer-features/main.zig b/test/link/wasm/infer-features/main.zig
new file mode 100644
index 0000000000..576faf61b6
--- /dev/null
+++ b/test/link/wasm/infer-features/main.zig
@@ -0,0 +1 @@
+extern fn foo() c_int;

From 3d1d19f3877190db42544acf9e0ed26784ba82ba Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Sun, 23 Oct 2022 20:02:25 +0200
Subject: [PATCH 17/70] wasm-linker: seperate linker -and cpu features

The list of features a Wasm object/binary file can emit can differ
from the list of cpu features. The reason for this is because the
"target_features" section also contains linker features. An example
of this is the "shared-mem" feature, which is a feature for the linker
and not that of the cpu target as defined by LLVM.
---
 src/link/Wasm.zig       | 18 +++++++++---------
 src/link/Wasm/types.zig | 24 +++++++++++++++++++++++-
 2 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index da9a878720..4b6895c4e5 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -654,15 +654,15 @@ fn resolveSymbolsInArchives(wasm: *Wasm) !void {
 fn validateFeatures(
     wasm: *const Wasm,
     arena: Allocator,
-    to_emit: *[@typeInfo(std.Target.wasm.Feature).Enum.fields.len]bool,
+    to_emit: *[@typeInfo(types.Feature.Tag).Enum.fields.len]bool,
     emit_features_count: *u32,
 ) !void {
     const cpu_features = wasm.base.options.target.cpu.features;
     const infer = cpu_features.isEmpty(); // when the user did not define any features, we infer them from linked objects.
-    var allowed = std.AutoHashMap(std.Target.wasm.Feature, void).init(arena);
-    var used = std.AutoArrayHashMap(std.Target.wasm.Feature, []const u8).init(arena);
-    var disallowed = std.AutoHashMap(std.Target.wasm.Feature, []const u8).init(arena);
-    var required = std.AutoHashMap(std.Target.wasm.Feature, []const u8).init(arena);
+    var allowed = std.AutoHashMap(types.Feature.Tag, void).init(arena);
+    var used = std.AutoArrayHashMap(types.Feature.Tag, []const u8).init(arena);
+    var disallowed = std.AutoHashMap(types.Feature.Tag, []const u8).init(arena);
+    var required = std.AutoHashMap(types.Feature.Tag, []const u8).init(arena);
 
     // when false, we fail linking. We only verify this after a loop to catch all invalid features.
     var valid_feature_set = true;
@@ -674,7 +674,7 @@ fn validateFeatures(
         // std.builtin.Type.EnumField
         inline for (@typeInfo(std.Target.wasm.Feature).Enum.fields) |feature_field| {
             if (cpu_features.isEnabled(feature_field.value)) {
-                allowed.putAssumeCapacityNoClobber(@intToEnum(std.Target.wasm.Feature, feature_field.value), {});
+                allowed.putAssumeCapacityNoClobber(@intToEnum(types.Feature.Tag, feature_field.value), {});
             }
         }
     }
@@ -730,7 +730,7 @@ fn validateFeatures(
 
     // For each linked object, validate the required and disallowed features
     for (wasm.objects.items) |object| {
-        var object_used_features = std.AutoHashMap(std.Target.wasm.Feature, void).init(arena);
+        var object_used_features = std.AutoHashMap(types.Feature.Tag, void).init(arena);
         try object_used_features.ensureTotalCapacity(@intCast(u32, object.features.len));
         for (object.features) |feature| {
             if (feature.prefix == .disallowed) continue; // already defined in 'disallowed' set.
@@ -764,7 +764,7 @@ fn validateFeatures(
     if (allowed.count() > 0) {
         emit_features_count.* = allowed.count();
         for (to_emit) |*feature_enabled, feature_index| {
-            feature_enabled.* = allowed.contains(@intToEnum(std.Target.wasm.Feature, feature_index));
+            feature_enabled.* = allowed.contains(@intToEnum(types.Feature.Tag, feature_index));
         }
     }
 }
@@ -2277,7 +2277,7 @@ pub fn flushModule(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Nod
     }
 
     var emit_features_count: u32 = 0;
-    var enabled_features: [@typeInfo(std.Target.wasm.Feature).Enum.fields.len]bool = undefined;
+    var enabled_features: [@typeInfo(types.Feature.Tag).Enum.fields.len]bool = undefined;
     try wasm.validateFeatures(arena, &enabled_features, &emit_features_count);
     try wasm.resolveSymbolsInArchives();
     try wasm.checkUndefinedSymbols();
diff --git a/src/link/Wasm/types.zig b/src/link/Wasm/types.zig
index 5e071c2f20..1b6df86d37 100644
--- a/src/link/Wasm/types.zig
+++ b/src/link/Wasm/types.zig
@@ -183,7 +183,27 @@ pub const Feature = struct {
     /// Type of the feature, must be unique in the sequence of features.
     tag: Tag,
 
-    pub const Tag = std.Target.wasm.Feature;
+    /// Unlike `std.Target.wasm.Feature` this also contains linker-features such as shared-mem
+    pub const Tag = enum {
+        atomics,
+        bulk_memory,
+        exception_handling,
+        extended_const,
+        multivalue,
+        mutable_globals,
+        nontrapping_fptoint,
+        reference_types,
+        relaxed_simd,
+        sign_ext,
+        simd128,
+        tail_call,
+        shared_mem,
+
+        /// From a given cpu feature, returns its linker feature
+        pub fn fromCpuFeature(feature: std.Target.wasm.Feature) Tag {
+            return @intToEnum(Tag, @enumToInt(feature));
+        }
+    };
 
     pub const Prefix = enum(u8) {
         used = '+',
@@ -205,6 +225,7 @@ pub const Feature = struct {
             .sign_ext => "sign-ext",
             .simd128 => "simd128",
             .tail_call => "tail-call",
+            .shared_mem => "shared-mem",
         };
     }
 
@@ -228,4 +249,5 @@ pub const known_features = std.ComptimeStringMap(Feature.Tag, .{
     .{ "sign-ext", .sign_ext },
     .{ "simd128", .simd128 },
     .{ "tail-call", .tail_call },
+    .{ "shared-mem", .shared_mem },
 });

From c0710b0c42716bb7173b9fcc2785f9bf5175ae0f Mon Sep 17 00:00:00 2001
From: Luuk de Gram <luuk@degram.dev>
Date: Tue, 25 Oct 2022 21:16:51 +0200
Subject: [PATCH 18/70] use fixed-size arrays for feature lists

Considering all possible features are known by the linker during
compile-time, we can create arrays on the stack instead of
dynamically allocating hash maps. We use a simple bitset to determine
whether a feature is enabled or not, and from which object file
it originates. This allows us to make feature validation slightly
faster and use less runtime memory.
In the future this could be enhanced further by having a single
array instead with a more sophisticated bitset.
---
 src/link.zig            |  1 +
 src/link/Wasm.zig       | 85 +++++++++++++++++------------------------
 src/link/Wasm/types.zig | 38 +++++++++---------
 3 files changed, 55 insertions(+), 69 deletions(-)

diff --git a/src/link.zig b/src/link.zig
index 9d4ac0d55b..39f51e90ec 100644
--- a/src/link.zig
+++ b/src/link.zig
@@ -696,6 +696,7 @@ pub const File = struct {
         GlobalTypeMismatch,
         InvalidCharacter,
         InvalidEntryKind,
+        InvalidFeatureSet,
         InvalidFormat,
         InvalidIndex,
         InvalidMagicByte,
diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig
index 4b6895c4e5..b9f2d74bd8 100644
--- a/src/link/Wasm.zig
+++ b/src/link/Wasm.zig
@@ -653,16 +653,17 @@ fn resolveSymbolsInArchives(wasm: *Wasm) !void {
 
 fn validateFeatures(
     wasm: *const Wasm,
-    arena: Allocator,
     to_emit: *[@typeInfo(types.Feature.Tag).Enum.fields.len]bool,
     emit_features_count: *u32,
 ) !void {
     const cpu_features = wasm.base.options.target.cpu.features;
     const infer = cpu_features.isEmpty(); // when the user did not define any features, we infer them from linked objects.
-    var allowed = std.AutoHashMap(types.Feature.Tag, void).init(arena);
-    var used = std.AutoArrayHashMap(types.Feature.Tag, []const u8).init(arena);
-    var disallowed = std.AutoHashMap(types.Feature.Tag, []const u8).init(arena);
-    var required = std.AutoHashMap(types.Feature.Tag, []const u8).init(arena);
+    const known_features_count = @typeInfo(types.Feature.Tag).Enum.fields.len;
+
+    var allowed = [_]bool{false} ** known_features_count;
+    var used = [_]u17{0} ** known_features_count;
+    var disallowed = [_]u17{0} ** known_features_count;
+    var required = [_]u17{0} ** known_features_count;
 
     // when false, we fail linking. We only verify this after a loop to catch all invalid features.
     var valid_feature_set = true;
@@ -670,41 +671,29 @@ fn validateFeatures(
     // When the user has given an explicit list of features to enable,
     // we extract them and insert each into the 'allowed' list.
     if (!infer) {
-        try allowed.ensureUnusedCapacity(std.Target.wasm.all_features.len);
-        // std.builtin.Type.EnumField
         inline for (@typeInfo(std.Target.wasm.Feature).Enum.fields) |feature_field| {
             if (cpu_features.isEnabled(feature_field.value)) {
-                allowed.putAssumeCapacityNoClobber(@intToEnum(types.Feature.Tag, feature_field.value), {});
+                allowed[feature_field.value] = true;
+                emit_features_count.* += 1;
             }
         }
     }
 
     // extract all the used, disallowed and required features from each
     // linked object file so we can test them.
-    for (wasm.objects.items) |object| {
+    for (wasm.objects.items) |object, object_index| {
         for (object.features) |feature| {
+            const value = @intCast(u16, object_index) << 1 | @as(u1, 1);
             switch (feature.prefix) {
                 .used => {
-                    const gop = try used.getOrPut(feature.tag);
-                    if (!gop.found_existing) {
-                        gop.value_ptr.* = object.name;
-                    }
+                    used[@enumToInt(feature.tag)] = value;
                 },
                 .disallowed => {
-                    const gop = try disallowed.getOrPut(feature.tag);
-                    if (!gop.found_existing) {
-                        gop.value_ptr.* = object.name;
-                    }
+                    disallowed[@enumToInt(feature.tag)] = value;
                 },
                 .required => {
-                    const gop = try required.getOrPut(feature.tag);
-                    if (!gop.found_existing) {
-                        gop.value_ptr.* = object.name;
-                    }
-                    const used_gop = try used.getOrPut(feature.tag);
-                    if (!used_gop.found_existing) {
-                        used_gop.value_ptr.* = object.name;
-                    }
+                    required[@enumToInt(feature.tag)] = value;
+                    used[@enumToInt(feature.tag)] = value;
                 },
             }
         }
@@ -713,13 +702,14 @@ fn validateFeatures(
     // when we infer the features, we allow each feature found in the 'used' set
     // and insert it into the 'allowed' set. When features are not inferred,
     // we validate that a used feature is allowed.
-    if (infer) try allowed.ensureUnusedCapacity(@intCast(u32, used.count()));
-    for (used.keys()) |used_feature, used_index| {
+    for (used) |used_set, used_index| {
+        const is_enabled = @truncate(u1, used_set) != 0;
         if (infer) {
-            allowed.putAssumeCapacityNoClobber(used_feature, {});
-        } else if (!allowed.contains(used_feature)) {
-            log.err("feature '{s}' not allowed, but used by linked object", .{@tagName(used_feature)});
-            log.err("  defined in '{s}'", .{used.values()[used_index]});
+            allowed[used_index] = is_enabled;
+            emit_features_count.* += @boolToInt(is_enabled);
+        } else if (is_enabled and !allowed[used_index]) {
+            log.err("feature '{s}' not allowed, but used by linked object", .{(@intToEnum(types.Feature.Tag, used_index)).toString()});
+            log.err("  defined in '{s}'", .{wasm.objects.items[used_set >> 1].name});
             valid_feature_set = false;
         }
     }
@@ -730,27 +720,27 @@ fn validateFeatures(
 
     // For each linked object, validate the required and disallowed features
     for (wasm.objects.items) |object| {
-        var object_used_features = std.AutoHashMap(types.Feature.Tag, void).init(arena);
-        try object_used_features.ensureTotalCapacity(@intCast(u32, object.features.len));
+        var object_used_features = [_]bool{false} ** known_features_count;
         for (object.features) |feature| {
             if (feature.prefix == .disallowed) continue; // already defined in 'disallowed' set.
             // from here a feature is always used
-            if (disallowed.get(feature.tag)) |disallowed_object_name| {
-                log.err("feature '{s}' is disallowed, but used by linked object", .{@tagName(feature.tag)});
-                log.err("  disallowed by '{s}'", .{disallowed_object_name});
+            const disallowed_feature = disallowed[@enumToInt(feature.tag)];
+            if (@truncate(u1, disallowed_feature) != 0) {
+                log.err("feature '{s}' is disallowed, but used by linked object", .{feature.tag.toString()});
+                log.err("  disallowed by '{s}'", .{wasm.objects.items[disallowed_feature >> 1].name});
                 log.err("  used in '{s}'", .{object.name});
                 valid_feature_set = false;
             }
 
-            object_used_features.putAssumeCapacity(feature.tag, {});
+            object_used_features[@enumToInt(feature.tag)] = true;
         }
 
         // validate the linked object file has each required feature
-        var required_it = required.iterator();
-        while (required_it.next()) |required_feature| {
-            if (!object_used_features.contains(required_feature.key_ptr.*)) {
-                log.err("feature '{s}' is required but not used in linked object", .{@tagName(required_feature.key_ptr.*)});
-                log.err("  required by '{s}'", .{required_feature.value_ptr.*});
+        for (required) |required_feature, feature_index| {
+            const is_required = @truncate(u1, required_feature) != 0;
+            if (is_required and !object_used_features[feature_index]) {
+                log.err("feature '{s}' is required but not used in linked object", .{(@intToEnum(types.Feature.Tag, feature_index)).toString()});
+                log.err("  required by '{s}'", .{wasm.objects.items[required_feature >> 1].name});
                 log.err("  missing in '{s}'", .{object.name});
                 valid_feature_set = false;
             }
@@ -761,12 +751,7 @@ fn validateFeatures(
         return error.InvalidFeatureSet;
     }
 
-    if (allowed.count() > 0) {
-        emit_features_count.* = allowed.count();
-        for (to_emit) |*feature_enabled, feature_index| {
-            feature_enabled.* = allowed.contains(@intToEnum(types.Feature.Tag, feature_index));
-        }
-    }
+    to_emit.* = allowed;
 }
 
 fn checkUndefinedSymbols(wasm: *const Wasm) !void {
@@ -2278,7 +2263,7 @@ pub fn flushModule(wasm: *Wasm, comp: *Compilation, prog_node: *std.Progress.Nod
 
     var emit_features_count: u32 = 0;
     var enabled_features: [@typeInfo(types.Feature.Tag).Enum.fields.len]bool = undefined;
-    try wasm.validateFeatures(arena, &enabled_features, &emit_features_count);
+    try wasm.validateFeatures(&enabled_features, &emit_features_count);
     try wasm.resolveSymbolsInArchives();
     try wasm.checkUndefinedSymbols();
 
@@ -2832,7 +2817,7 @@ fn emitFeaturesSection(binary_bytes: *std.ArrayList(u8), enabled_features: []con
         if (enabled) {
             const feature: types.Feature = .{ .prefix = .used, .tag = @intToEnum(types.Feature.Tag, feature_index) };
             try leb.writeULEB128(writer, @enumToInt(feature.prefix));
-            const string = feature.toString();
+            const string = feature.tag.toString();
             try leb.writeULEB128(writer, @intCast(u32, string.len));
             try writer.writeAll(string);
         }
diff --git a/src/link/Wasm/types.zig b/src/link/Wasm/types.zig
index 1b6df86d37..a46fad4e53 100644
--- a/src/link/Wasm/types.zig
+++ b/src/link/Wasm/types.zig
@@ -203,6 +203,24 @@ pub const Feature = struct {
         pub fn fromCpuFeature(feature: std.Target.wasm.Feature) Tag {
             return @intToEnum(Tag, @enumToInt(feature));
         }
+
+        pub fn toString(tag: Tag) []const u8 {
+            return switch (tag) {
+                .atomics => "atomics",
+                .bulk_memory => "bulk-memory",
+                .exception_handling => "exception-handling",
+                .extended_const => "extended-const",
+                .multivalue => "multivalue",
+                .mutable_globals => "mutable-globals",
+                .nontrapping_fptoint => "nontrapping-fptoint",
+                .reference_types => "reference-types",
+                .relaxed_simd => "relaxed-simd",
+                .sign_ext => "sign-ext",
+                .simd128 => "simd128",
+                .tail_call => "tail-call",
+                .shared_mem => "shared-mem",
+            };
+        }
     };
 
     pub const Prefix = enum(u8) {
@@ -211,28 +229,10 @@ pub const Feature = struct {
         required = '=',
     };
 
-    pub fn toString(feature: Feature) []const u8 {
-        return switch (feature.tag) {
-            .atomics => "atomics",
-            .bulk_memory => "bulk-memory",
-            .exception_handling => "exception-handling",
-            .extended_const => "extended-const",
-            .multivalue => "multivalue",
-            .mutable_globals => "mutable-globals",
-            .nontrapping_fptoint => "nontrapping-fptoint",
-            .reference_types => "reference-types",
-            .relaxed_simd => "relaxed-simd",
-            .sign_ext => "sign-ext",
-            .simd128 => "simd128",
-            .tail_call => "tail-call",
-            .shared_mem => "shared-mem",
-        };
-    }
-
     pub fn format(feature: Feature, comptime fmt: []const u8, opt: std.fmt.FormatOptions, writer: anytype) !void {
         _ = opt;
         _ = fmt;
-        try writer.print("{c} {s}", .{ feature.prefix, feature.toString() });
+        try writer.print("{c} {s}", .{ feature.prefix, feature.tag.toString() });
     }
 };
 

From 73c2e91a0dee356048898d5b72e01969af9097e3 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Tue, 25 Oct 2022 23:55:58 +0200
Subject: [PATCH 19/70] build: include -lzstd in the linker line when building
 Zig

---
 build.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/build.zig b/build.zig
index 30508b88e3..538549ea91 100644
--- a/build.zig
+++ b/build.zig
@@ -635,6 +635,7 @@ fn addStaticLlvmOptionsToExe(exe: *std.build.LibExeObjStep) !void {
     }
 
     exe.linkSystemLibrary("z");
+    exe.linkSystemLibrary("zstd");
 
     // This means we rely on clang-or-zig-built LLVM, Clang, LLD libraries.
     exe.linkSystemLibrary("c++");

From 0010288dae32d12af60edd3f287025030a3f5dcd Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 25 Oct 2022 17:16:36 -0700
Subject: [PATCH 20/70] CI: update macos and windows tarballs

---
 ci/azure/macos_script  | 2 +-
 ci/azure/pipelines.yml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/ci/azure/macos_script b/ci/azure/macos_script
index 5b3dfbb341..a75809fa8b 100755
--- a/ci/azure/macos_script
+++ b/ci/azure/macos_script
@@ -9,7 +9,7 @@ ZIGDIR="$(pwd)"
 ARCH="x86_64"
 TARGET="$ARCH-macos-none"
 MCPU="baseline"
-CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.10.0-dev.4111+5206832a8"
+CACHE_BASENAME="zig+llvm+lld+clang-$TARGET-0.10.0-dev.4560+828735ac0"
 PREFIX="$HOME/$CACHE_BASENAME"
 JOBS="-j2"
 
diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index e35ea4f328..cedc33c8b5 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -16,7 +16,7 @@ jobs:
     vmImage: 'windows-2019'
   variables:
     TARGET: 'x86_64-windows-gnu'
-    ZIG_LLVM_CLANG_LLD_NAME: 'zig+llvm+lld+clang-${{ variables.TARGET }}-0.10.0-dev.4459+4f9345d20'
+    ZIG_LLVM_CLANG_LLD_NAME: 'zig+llvm+lld+clang-${{ variables.TARGET }}-0.10.0-dev.4560+828735ac0'
     ZIG_LLVM_CLANG_LLD_URL: 'https://ziglang.org/deps/${{ variables.ZIG_LLVM_CLANG_LLD_NAME }}.zip'
   steps:
   - pwsh: |

From 8fc7b4d1401a70358bf54023363178d9c3e1f9de Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 25 Oct 2022 18:29:39 -0700
Subject: [PATCH 21/70] CMake: handle zstd the same as zlib

This is a new dependency of LLVM 15.
---
 CMakeLists.txt | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3b540045e5..3be09c028e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -88,6 +88,7 @@ set(ZIG_STATIC off CACHE BOOL "Attempt to build a static zig executable (not com
 set(ZIG_SHARED_LLVM off CACHE BOOL "Prefer linking against shared LLVM libraries")
 set(ZIG_STATIC_LLVM off CACHE BOOL "Prefer linking against static LLVM libraries")
 set(ZIG_STATIC_ZLIB off CACHE BOOL "Prefer linking against static zlib")
+set(ZIG_STATIC_ZSTD off CACHE BOOL "Prefer linking against static zstd")
 set(ZIG_USE_CCACHE off CACHE BOOL "Use ccache if available")
 
 if(CCACHE_PROGRAM AND ZIG_USE_CCACHE)
@@ -97,6 +98,7 @@ endif()
 if(ZIG_STATIC)
     set(ZIG_STATIC_LLVM ON)
     set(ZIG_STATIC_ZLIB ON)
+    set(ZIG_STATIC_ZSTD ON)
 endif()
 
 if (ZIG_SHARED_LLVM AND ZIG_STATIC_LLVM)
@@ -137,6 +139,12 @@ if(ZIG_STATIC_ZLIB)
     list(APPEND LLVM_LIBRARIES "${ZLIB}")
 endif()
 
+if(ZIG_STATIC_ZSTD)
+    list(REMOVE_ITEM LLVM_LIBRARIES "-lzstd")
+    find_library(ZSTD NAMES libzstd.a libzstdstatic.a zstd NAMES_PER_DIR)
+    list(APPEND LLVM_LIBRARIES "${ZSTD}")
+endif()
+
 if(APPLE AND ZIG_STATIC)
     list(REMOVE_ITEM LLVM_LIBRARIES "-lcurses")
     find_library(CURSES NAMES libcurses.a libncurses.a NAMES_PER_DIR

From e490d9e5179331c370b8ab2241d3e2c6bc57ec2e Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Tue, 25 Oct 2022 19:22:34 -0700
Subject: [PATCH 22/70] CI: update drone and zinc tarballs

---
 ci/drone/drone.yml             | 18 +++++++++---------
 ci/drone/linux_script_finalize |  4 ----
 ci/zinc/drone.yml              | 14 +++++++-------
 3 files changed, 16 insertions(+), 20 deletions(-)

diff --git a/ci/drone/drone.yml b/ci/drone/drone.yml
index 1be912143b..00a5db3cc7 100644
--- a/ci/drone/drone.yml
+++ b/ci/drone/drone.yml
@@ -9,56 +9,56 @@ platform:
 
 steps:
 - name: build
-  image: ziglang/static-base:llvm15-aarch64-2
+  image: ziglang/static-base:llvm15-aarch64-3
   commands:
   - ./ci/drone/linux_script_build
 
 - name: behavior
   depends_on:
   - build
-  image: ziglang/static-base:llvm15-aarch64-2
+  image: ziglang/static-base:llvm15-aarch64-3
   commands:
   - ./ci/drone/test_linux_behavior
 
 - name: std_Debug
   depends_on:
   - build
-  image: ziglang/static-base:llvm15-aarch64-2
+  image: ziglang/static-base:llvm15-aarch64-3
   commands:
   - ./ci/drone/test_linux_std_Debug
 
 - name: std_ReleaseSafe
   depends_on:
   - build
-  image: ziglang/static-base:llvm15-aarch64-2
+  image: ziglang/static-base:llvm15-aarch64-3
   commands:
   - ./ci/drone/test_linux_std_ReleaseSafe
 
 - name: std_ReleaseFast
   depends_on:
   - build
-  image: ziglang/static-base:llvm15-aarch64-2
+  image: ziglang/static-base:llvm15-aarch64-3
   commands:
   - ./ci/drone/test_linux_std_ReleaseFast
 
 - name: std_ReleaseSmall
   depends_on:
   - build
-  image: ziglang/static-base:llvm15-aarch64-2
+  image: ziglang/static-base:llvm15-aarch64-3
   commands:
   - ./ci/drone/test_linux_std_ReleaseSmall
 
 - name: misc
   depends_on:
   - build
-  image: ziglang/static-base:llvm15-aarch64-2
+  image: ziglang/static-base:llvm15-aarch64-3
   commands:
   - ./ci/drone/test_linux_misc
 
 - name: cases
   depends_on:
   - build
-  image: ziglang/static-base:llvm15-aarch64-2
+  image: ziglang/static-base:llvm15-aarch64-3
   commands:
   - ./ci/drone/test_linux_cases
 
@@ -72,7 +72,7 @@ steps:
   - std_ReleaseSmall
   - misc
   - cases
-  image: ziglang/static-base:llvm15-aarch64-2
+  image: ziglang/static-base:llvm15-aarch64-3
   environment:
     SRHT_OAUTH_TOKEN:
       from_secret: SRHT_OAUTH_TOKEN
diff --git a/ci/drone/linux_script_finalize b/ci/drone/linux_script_finalize
index 43ff5f8f0e..5f021fbaa5 100755
--- a/ci/drone/linux_script_finalize
+++ b/ci/drone/linux_script_finalize
@@ -12,10 +12,6 @@ if [ -n "$DRONE_PULL_REQUEST" ]; then
   exit 0
 fi
 
-apk update
-apk add py3-pip perl-utils jq curl
-pip3 install s3cmd
-
 cd build
 
 mv ../LICENSE "$INSTALL_PREFIX/"
diff --git a/ci/zinc/drone.yml b/ci/zinc/drone.yml
index 57eadb9eee..6f48fe4c13 100644
--- a/ci/zinc/drone.yml
+++ b/ci/zinc/drone.yml
@@ -10,28 +10,28 @@ workspace:
 
 steps:
 - name: configure_git
-  image: ci/debian-amd64:11.1-11
+  image: ci/debian-amd64:11.1-12
   commands:
   - ./ci/zinc/configure_git
 
 - name: test_stage3_debug
   depends_on:
   - configure_git
-  image: ci/debian-amd64:11.1-11
+  image: ci/debian-amd64:11.1-12
   commands:
   - ./ci/zinc/linux_test_stage3_debug
 
 - name: test_stage3_release
   depends_on:
   - configure_git
-  image: ci/debian-amd64:11.1-11
+  image: ci/debian-amd64:11.1-12
   commands:
   - ./ci/zinc/linux_test_stage3_release
 
 - name: build_aarch64_macos
   depends_on:
   - test_stage3_release
-  image: ci/debian-amd64:11.1-11
+  image: ci/debian-amd64:11.1-12
   commands:
   - ./ci/zinc/build_aarch64_macos
 
@@ -44,7 +44,7 @@ steps:
       - master
     event:
       - push
-  image: ci/debian-amd64:11.1-11
+  image: ci/debian-amd64:11.1-12
   environment:
     AWS_ACCESS_KEY_ID:
       from_secret: AWS_ACCESS_KEY_ID
@@ -62,7 +62,7 @@ steps:
       - master
     event:
       - push
-  image: ci/debian-amd64:11.1-11
+  image: ci/debian-amd64:11.1-12
   environment:
     AWS_ACCESS_KEY_ID:
       from_secret: AWS_ACCESS_KEY_ID
@@ -80,7 +80,7 @@ steps:
       - master
     event:
       - push
-  image: ci/debian-amd64:11.1-11
+  image: ci/debian-amd64:11.1-12
   environment:
     SRHT_OAUTH_TOKEN:
       from_secret: SRHT_OAUTH_TOKEN

From 22b71b1376eaa75aa141022404d6ddf40495c886 Mon Sep 17 00:00:00 2001
From: Frank Denis <github@pureftpd.org>
Date: Tue, 25 Oct 2022 20:34:24 +0200
Subject: [PATCH 23/70] crypto/bcrypt: don't reimplement base64, just use a
 custom alphabet

Now that std.base64 supports everything bcrypt needs to encode its
parameters, we don't need to include another implementation.
---
 lib/std/crypto/bcrypt.zig | 80 +++++----------------------------------
 1 file changed, 10 insertions(+), 70 deletions(-)

diff --git a/lib/std/crypto/bcrypt.zig b/lib/std/crypto/bcrypt.zig
index d7a0e0fb80..f924ab681c 100644
--- a/lib/std/crypto/bcrypt.zig
+++ b/lib/std/crypto/bcrypt.zig
@@ -1,4 +1,5 @@
 const std = @import("std");
+const base64 = std.base64;
 const crypto = std.crypto;
 const debug = std.debug;
 const fmt = std.fmt;
@@ -533,71 +534,10 @@ const crypt_format = struct {
     pub const prefix = "$2";
 
     // bcrypt has its own variant of base64, with its own alphabet and no padding
-    const Codec = struct {
-        const alphabet = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-
-        fn encode(b64: []u8, bin: []const u8) void {
-            var i: usize = 0;
-            var j: usize = 0;
-            while (i < bin.len) {
-                var c1 = bin[i];
-                i += 1;
-                b64[j] = alphabet[c1 >> 2];
-                j += 1;
-                c1 = (c1 & 3) << 4;
-                if (i >= bin.len) {
-                    b64[j] = alphabet[c1];
-                    j += 1;
-                    break;
-                }
-                var c2 = bin[i];
-                i += 1;
-                c1 |= (c2 >> 4) & 0x0f;
-                b64[j] = alphabet[c1];
-                j += 1;
-                c1 = (c2 & 0x0f) << 2;
-                if (i >= bin.len) {
-                    b64[j] = alphabet[c1];
-                    j += 1;
-                    break;
-                }
-                c2 = bin[i];
-                i += 1;
-                c1 |= (c2 >> 6) & 3;
-                b64[j] = alphabet[c1];
-                b64[j + 1] = alphabet[c2 & 0x3f];
-                j += 2;
-            }
-            debug.assert(j == b64.len);
-        }
-
-        fn decode(bin: []u8, b64: []const u8) EncodingError!void {
-            var i: usize = 0;
-            var j: usize = 0;
-            while (j < bin.len) {
-                const c1 = @intCast(u8, mem.indexOfScalar(u8, alphabet, b64[i]) orelse
-                    return EncodingError.InvalidEncoding);
-                const c2 = @intCast(u8, mem.indexOfScalar(u8, alphabet, b64[i + 1]) orelse
-                    return EncodingError.InvalidEncoding);
-                bin[j] = (c1 << 2) | ((c2 & 0x30) >> 4);
-                j += 1;
-                if (j >= bin.len) {
-                    break;
-                }
-                const c3 = @intCast(u8, mem.indexOfScalar(u8, alphabet, b64[i + 2]) orelse
-                    return EncodingError.InvalidEncoding);
-                bin[j] = ((c2 & 0x0f) << 4) | ((c3 & 0x3c) >> 2);
-                j += 1;
-                if (j >= bin.len) {
-                    break;
-                }
-                const c4 = @intCast(u8, mem.indexOfScalar(u8, alphabet, b64[i + 3]) orelse
-                    return EncodingError.InvalidEncoding);
-                bin[j] = ((c3 & 0x03) << 6) | c4;
-                j += 1;
-                i += 4;
-            }
-        }
+    const bcrypt_alphabet = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".*;
+    const Codec = struct { Encoder: base64.Base64Encoder, Decoder: base64.Base64Decoder }{
+        .Encoder = base64.Base64Encoder.init(bcrypt_alphabet, null),
+        .Decoder = base64.Base64Decoder.init(bcrypt_alphabet, null),
     };
 
     fn strHashInternal(
@@ -608,10 +548,10 @@ const crypt_format = struct {
         var dk = bcrypt(password, salt, params);
 
         var salt_str: [salt_str_length]u8 = undefined;
-        Codec.encode(salt_str[0..], salt[0..]);
+        _ = Codec.Encoder.encode(salt_str[0..], salt[0..]);
 
         var ct_str: [ct_str_length]u8 = undefined;
-        Codec.encode(ct_str[0..], dk[0..]);
+        _ = Codec.Encoder.encode(ct_str[0..], dk[0..]);
 
         var s_buf: [hash_length]u8 = undefined;
         const s = fmt.bufPrint(
@@ -709,7 +649,7 @@ const CryptFormatHasher = struct {
 
         const salt_str = str[7..][0..salt_str_length];
         var salt: [salt_length]u8 = undefined;
-        try crypt_format.Codec.decode(salt[0..], salt_str[0..]);
+        crypt_format.Codec.Decoder.decode(salt[0..], salt_str[0..]) catch return HasherError.InvalidEncoding;
 
         const wanted_s = crypt_format.strHashInternal(password, salt, .{ .rounds_log = rounds_log });
         if (!mem.eql(u8, wanted_s[0..], str[0..])) return HasherError.PasswordVerificationFailed;
@@ -764,9 +704,9 @@ test "bcrypt codec" {
     var salt: [salt_length]u8 = undefined;
     crypto.random.bytes(&salt);
     var salt_str: [salt_str_length]u8 = undefined;
-    crypt_format.Codec.encode(salt_str[0..], salt[0..]);
+    _ = crypt_format.Codec.Encoder.encode(salt_str[0..], salt[0..]);
     var salt2: [salt_length]u8 = undefined;
-    try crypt_format.Codec.decode(salt2[0..], salt_str[0..]);
+    try crypt_format.Codec.Decoder.decode(salt2[0..], salt_str[0..]);
     try testing.expectEqualSlices(u8, salt[0..], salt2[0..]);
 }
 

From 453a2d2fad5728ed0a7fe85dd90e26cc00b938d1 Mon Sep 17 00:00:00 2001
From: Jakub Konka <kubkon@jakubkonka.com>
Date: Wed, 26 Oct 2022 08:53:33 +0200
Subject: [PATCH 24/70] darwin: remove 10.15.7 as available libc from
 src/target.zig

---
 src/target.zig | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/target.zig b/src/target.zig
index fc585912c4..079d115161 100644
--- a/src/target.zig
+++ b/src/target.zig
@@ -71,7 +71,6 @@ pub const available_libcs = [_]ArchOsAbi{
     .{ .arch = .x86_64, .os = .linux, .abi = .gnux32 },
     .{ .arch = .x86_64, .os = .linux, .abi = .musl },
     .{ .arch = .x86_64, .os = .windows, .abi = .gnu },
-    .{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 10, .minor = 0 } },
     .{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 11, .minor = 0 } },
     .{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 12, .minor = 0 } },
     .{ .arch = .x86_64, .os = .macos, .abi = .none, .os_ver = .{ .major = 13, .minor = 0 } },

From cd4865d88c368095e131d2d95d3cce637db0ff5a Mon Sep 17 00:00:00 2001
From: Naoki MATSUMOTO <33079554+naoki9911@users.noreply.github.com>
Date: Wed, 26 Oct 2022 20:18:06 +0900
Subject: [PATCH 25/70] std.crypto.sign.ecdsa: accepts unusual parameters like
 EcdsaP384Sha256 (#13302)

This commit accepts unusual parameters like EcdsaP384Sha256.
Some certifictes(below certs are in /etc/ssl/certs/ca-certificates.crt on Ubuntu 22.04) use EcdsaP384Sha256 to sign itself.
- Subject: C=GR, L=Athens, O=Hellenic Academic and Research Institutions Cert. Authority, CN=Hellenic Academic and Research Institutions ECC RootCA 2015
- Subject: C=US, ST=Texas, L=Houston, O=SSL Corporation, CN=SSL.com EV Root Certification Authority ECC
- Subject: C=US, ST=Texas, L=Houston, O=SSL Corporation, CN=SSL.com Root Certification Authority ECC

In verify(), hash array `h` is allocated to be larger than the scalar.encoded_length.
The array is regarded as big-endian.
Hash values are filled in the back of the array and the rest bytes in front are filled with zero.

In sign(), the hash array is allocated and filled as same as verify().
In deterministicScalar(), hash bytes are insufficient to generate `k`
To generate `k` without narrowing its value range,
this commit uses algorithm stage h. in  "Section 3.2 Generation of k" in RFC6979.
---
 lib/std/crypto/ecdsa.zig | 76 +++++++++++++++++++++++++++++++++++-----
 1 file changed, 67 insertions(+), 9 deletions(-)

diff --git a/lib/std/crypto/ecdsa.zig b/lib/std/crypto/ecdsa.zig
index 3360d7bb87..ee27e23a75 100644
--- a/lib/std/crypto/ecdsa.zig
+++ b/lib/std/crypto/ecdsa.zig
@@ -92,10 +92,11 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
                 const s = try Curve.scalar.Scalar.fromBytes(self.s, .Big);
                 if (r.isZero() or s.isZero()) return error.IdentityElement;
 
-                var h: [Hash.digest_length]u8 = undefined;
-                Hash.hash(msg, &h, .{});
-
                 const ht = Curve.scalar.encoded_length;
+                const h_len = @max(Hash.digest_length, ht);
+                var h: [h_len]u8 = [_]u8{0} ** h_len;
+                Hash.hash(msg, h[h_len - Hash.digest_length .. h_len], .{});
+
                 const z = reduceToScalar(ht, h[0..ht].*);
                 if (z.isZero()) {
                     return error.SignatureVerificationFailed;
@@ -228,14 +229,16 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             pub fn sign(key_pair: KeyPair, msg: []const u8, noise: ?[noise_length]u8) (IdentityElementError || NonCanonicalError)!Signature {
                 const secret_key = key_pair.secret_key;
 
-                var h: [Hash.digest_length]u8 = undefined;
-                Hash.hash(msg, &h, .{});
-
                 const scalar_encoded_length = Curve.scalar.encoded_length;
+                const h_len = @max(Hash.digest_length, scalar_encoded_length);
+                var h: [h_len]u8 = [_]u8{0} ** h_len;
+                var h_slice = h[h_len - Hash.digest_length .. h_len];
+                Hash.hash(msg, h_slice, .{});
+
                 std.debug.assert(h.len >= scalar_encoded_length);
                 const z = reduceToScalar(scalar_encoded_length, h[0..scalar_encoded_length].*);
 
-                const k = deterministicScalar(h, secret_key.bytes, noise);
+                const k = deterministicScalar(h_slice.*, secret_key.bytes, noise);
 
                 const p = try Curve.basePoint.mul(k.toBytes(.Big), .Big);
                 const xs = p.affineCoordinates().x.toBytes(.Big);
@@ -268,6 +271,7 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
         fn deterministicScalar(h: [Hash.digest_length]u8, secret_key: Curve.scalar.CompressedScalar, noise: ?[noise_length]u8) Curve.scalar.Scalar {
             var k = [_]u8{0x00} ** h.len;
             var m = [_]u8{0x00} ** (h.len + 1 + noise_length + secret_key.len + h.len);
+            var t = [_]u8{0x00} ** Curve.scalar.encoded_length;
             const m_v = m[0..h.len];
             const m_i = &m[m_v.len];
             const m_z = m[m_v.len + 1 ..][0..noise_length];
@@ -286,8 +290,13 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             Hmac.create(&k, &m, &k);
             Hmac.create(m_v, m_v, &k);
             while (true) {
-                Hmac.create(m_v, m_v, &k);
-                if (Curve.scalar.Scalar.fromBytes(m_v[0..Curve.scalar.encoded_length].*, .Big)) |s| return s else |_| {}
+                var t_off: usize = 0;
+                while (t_off < t.len) : (t_off += m_v.len) {
+                    const t_end = @min(t_off + m_v.len, t.len);
+                    Hmac.create(m_v, m_v, &k);
+                    std.mem.copy(u8, t[t_off..t_end], m_v[0 .. t_end - t_off]);
+                }
+                if (Curve.scalar.Scalar.fromBytes(t, .Big)) |s| return s else |_| {}
                 mem.copy(u8, m_v, m_v);
                 m_i.* = 0x00;
                 Hmac.create(&k, m[0 .. m_v.len + 1], &k);
@@ -325,6 +334,55 @@ test "ECDSA - Basic operations over Secp256k1" {
     try sig2.verify(msg, kp.public_key);
 }
 
+test "ECDSA - Basic operations over EcdsaP384Sha256" {
+    const Scheme = Ecdsa(crypto.ecc.P384, crypto.hash.sha2.Sha256);
+    const kp = try Scheme.KeyPair.create(null);
+    const msg = "test";
+
+    var noise: [Scheme.noise_length]u8 = undefined;
+    crypto.random.bytes(&noise);
+    const sig = try kp.sign(msg, noise);
+    try sig.verify(msg, kp.public_key);
+
+    const sig2 = try kp.sign(msg, null);
+    try sig2.verify(msg, kp.public_key);
+}
+
+test "ECDSA - Verifying a existing signature with EcdsaP384Sha256" {
+    const Scheme = Ecdsa(crypto.ecc.P384, crypto.hash.sha2.Sha256);
+    // zig fmt: off
+    const sk_bytes = [_]u8{
+    0x6a, 0x53, 0x9c, 0x83, 0x0f, 0x06, 0x86, 0xd9, 0xef, 0xf1, 0xe7, 0x5c, 0xae,
+    0x93, 0xd9, 0x5b, 0x16, 0x1e, 0x96, 0x7c, 0xb0, 0x86, 0x35, 0xc9, 0xea, 0x20,
+    0xdc, 0x2b, 0x02, 0x37, 0x6d, 0xd2, 0x89, 0x72, 0x0a, 0x37, 0xf6, 0x5d, 0x4f,
+    0x4d, 0xf7, 0x97, 0xcb, 0x8b, 0x03, 0x63, 0xc3, 0x2d
+    };
+    const msg = [_]u8{
+    0x64, 0x61, 0x74, 0x61, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x73, 0x69, 0x67, 0x6e,
+    0x69, 0x6e, 0x67, 0x0a
+    };
+    const sig_ans_bytes = [_]u8{
+    0x30, 0x64, 0x02, 0x30, 0x7a, 0x31, 0xd8, 0xe0, 0xf8, 0x40, 0x7d, 0x6a, 0xf3,
+    0x1a, 0x5d, 0x02, 0xe5, 0xcb, 0x24, 0x29, 0x1a, 0xac, 0x15, 0x94, 0xd1, 0x5b,
+    0xcd, 0x75, 0x2f, 0x45, 0x79, 0x98, 0xf7, 0x60, 0x9a, 0xd5, 0xca, 0x80, 0x15,
+    0x87, 0x9b, 0x0c, 0x27, 0xe3, 0x01, 0x8b, 0x73, 0x4e, 0x57, 0xa3, 0xd2, 0x9a,
+    0x02, 0x30, 0x33, 0xe0, 0x04, 0x5e, 0x76, 0x1f, 0xc8, 0xcf, 0xda, 0xbe, 0x64,
+    0x95, 0x0a, 0xd4, 0x85, 0x34, 0x33, 0x08, 0x7a, 0x81, 0xf2, 0xf6, 0xb6, 0x94,
+    0x68, 0xc3, 0x8c, 0x5f, 0x88, 0x92, 0x27, 0x5e, 0x4e, 0x84, 0x96, 0x48, 0x42,
+    0x84, 0x28, 0xac, 0x37, 0x93, 0x07, 0xd3, 0x50, 0x32, 0x71, 0xb0
+    };
+    // zig fmt: on
+
+    const sk = try Scheme.SecretKey.fromBytes(sk_bytes);
+    const kp = try Scheme.KeyPair.fromSecretKey(sk);
+
+    const sig_ans = try Scheme.Signature.fromDer(&sig_ans_bytes);
+    try sig_ans.verify(&msg, kp.public_key);
+
+    const sig = try kp.sign(&msg, null);
+    try sig.verify(&msg, kp.public_key);
+}
+
 const TestVector = struct {
     key: []const u8,
     msg: []const u8,

From 9db293492bbbc5b8d70638bd9c59dea19d13596c Mon Sep 17 00:00:00 2001
From: Hadrien Dorio <hadrien.dorio@gmail.com>
Date: Sat, 20 Aug 2022 21:08:02 +0000
Subject: [PATCH 26/70] make a .rsp file for `zig clang`

same as std.build.LibExeObjStep.make() for `zig build-exe`
closes #12419
---
 src/Compilation.zig | 67 +++++++++++++++++++++++++++++++++++++++++++++
 test/standalone.zig |  5 +---
 2 files changed, 68 insertions(+), 4 deletions(-)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index fc71da56f3..5c3db25555 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -7,6 +7,9 @@ const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
 const log = std.log.scoped(.compilation);
 const Target = std.Target;
+const ArrayList = std.ArrayList;
+const Sha256 = std.crypto.hash.sha2.Sha256;
+const fs = std.fs;
 
 const Value = @import("value.zig").Value;
 const Type = @import("type.zig").Type;
@@ -3915,6 +3918,70 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: *std.P
             }
         }
 
+        // Windows has an argument length limit of 32,766 characters, macOS 262,144 and Linux
+        // 2,097,152. If our args exceed 30 KiB, we instead write them to a "response file" and
+        // pass that to zig, e.g. via 'zig build-lib @args.rsp'
+        // See @file syntax here: https://gcc.gnu.org/onlinedocs/gcc/Overall-Options.html
+        var args_length: usize = 0;
+        for (argv.items) |arg| {
+            args_length += arg.len + 1; // +1 to account for null terminator
+        }
+        if (args_length >= 30 * 1024) {
+            const allocator = comp.gpa;
+            const input_args = argv.items[2..];
+            const output_dir = comp.local_cache_directory;
+
+            var args_arena = std.heap.ArenaAllocator.init(allocator);
+            defer args_arena.deinit();
+
+            const args_to_escape = input_args;
+            var escaped_args = try ArrayList([]const u8).initCapacity(args_arena.allocator(), args_to_escape.len);
+
+            arg_blk: for (args_to_escape) |arg| {
+                for (arg) |c, arg_idx| {
+                    if (c == '\\' or c == '"') {
+                        // Slow path for arguments that need to be escaped. We'll need to allocate and copy
+                        var escaped = try ArrayList(u8).initCapacity(args_arena.allocator(), arg.len + 1);
+                        const writer = escaped.writer();
+                        writer.writeAll(arg[0..arg_idx]) catch unreachable;
+                        for (arg[arg_idx..]) |to_escape| {
+                            if (to_escape == '\\' or to_escape == '"') try writer.writeByte('\\');
+                            try writer.writeByte(to_escape);
+                        }
+                        escaped_args.appendAssumeCapacity(escaped.items);
+                        continue :arg_blk;
+                    }
+                }
+                escaped_args.appendAssumeCapacity(arg); // no escaping needed so just use original argument
+            }
+
+            const partially_quoted = try std.mem.join(allocator, "\" \"", escaped_args.items);
+            const args = try std.mem.concat(allocator, u8, &[_][]const u8{ "\"", partially_quoted, "\"" });
+
+            // Write the args to zig-cache/args/<SHA256 hash of args> to avoid conflicts with
+            // other zig build commands running in parallel.
+
+            var args_hash: [Sha256.digest_length]u8 = undefined;
+            Sha256.hash(args, &args_hash, .{});
+            var args_hex_hash: [Sha256.digest_length * 2]u8 = undefined;
+            _ = try std.fmt.bufPrint(
+                &args_hex_hash,
+                "{s}",
+                .{std.fmt.fmtSliceHexLower(&args_hash)},
+            );
+
+            const args_dir = "args";
+            try output_dir.handle.makePath(args_dir);
+            const args_file = try fs.path.join(allocator, &[_][]const u8{
+                args_dir, args_hex_hash[0..],
+            });
+            try output_dir.handle.writeFile(args_file, args);
+            const args_file_path = try output_dir.handle.realpathAlloc(allocator, args_file);
+
+            argv.shrinkRetainingCapacity(2);
+            try argv.append(try std.mem.concat(allocator, u8, &[_][]const u8{ "@", args_file_path }));
+        }
+
         if (comp.verbose_cc) {
             dump_argv(argv.items);
         }
diff --git a/test/standalone.zig b/test/standalone.zig
index f0567943b6..c945fe6bb6 100644
--- a/test/standalone.zig
+++ b/test/standalone.zig
@@ -37,10 +37,7 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
     if (builtin.zig_backend == .stage1) { // https://github.com/ziglang/zig/issues/12194
         cases.addBuildFile("test/standalone/issue_9812/build.zig", .{});
     }
-    if (builtin.os.tag != .windows) {
-        // https://github.com/ziglang/zig/issues/12419
-        cases.addBuildFile("test/standalone/issue_11595/build.zig", .{});
-    }
+    cases.addBuildFile("test/standalone/issue_11595/build.zig", .{});
     if (builtin.os.tag != .wasi) {
         cases.addBuildFile("test/standalone/load_dynamic_library/build.zig", .{});
     }

From db799ae628cc3a131c34f8ae4b7422d7e9520cff Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 24 Oct 2022 22:42:01 +0300
Subject: [PATCH 27/70] Module: mitigate generic deletion bug

---
 src/Module.zig | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/Module.zig b/src/Module.zig
index 4f150b0148..9a395d72c4 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -3367,6 +3367,8 @@ pub fn deinit(mod: *Module) void {
     for (mod.import_table.keys()) |key| {
         gpa.free(key);
     }
+    var failed_decls = mod.failed_decls;
+    mod.failed_decls = .{};
     for (mod.import_table.values()) |value| {
         value.destroy(mod);
     }
@@ -3406,10 +3408,10 @@ pub fn deinit(mod: *Module) void {
     mod.local_zir_cache.handle.close();
     mod.global_zir_cache.handle.close();
 
-    for (mod.failed_decls.values()) |value| {
+    for (failed_decls.values()) |value| {
         value.destroy(gpa);
     }
-    mod.failed_decls.deinit(gpa);
+    failed_decls.deinit(gpa);
 
     if (mod.emit_h) |emit_h| {
         for (emit_h.failed_decls.values()) |value| {
@@ -3482,6 +3484,13 @@ pub fn deinit(mod: *Module) void {
 pub fn destroyDecl(mod: *Module, decl_index: Decl.Index) void {
     const gpa = mod.gpa;
     {
+        if (mod.failed_decls.contains(decl_index)) {
+            blk: {
+                const errs = mod.comp.getAllErrorsAlloc() catch break :blk;
+                for (errs.list) |err| Compilation.AllErrors.Message.renderToStdErr(err, .no_color);
+            }
+            @panic("Zig compiler bug: attempted to destroy declaration with an attached error");
+        }
         const decl = mod.declPtr(decl_index);
         log.debug("destroy {*} ({s})", .{ decl, decl.name });
         _ = mod.test_functions.swapRemove(decl_index);

From b12a5cea7559c4cd4666f142b3e05265b07fe323 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Thu, 27 Oct 2022 01:00:33 +0300
Subject: [PATCH 28/70] remove test case triggering generic deletion bug

This test should be restored once the underlying issue is resolved (with the typo fixed).
---
 src/Module.zig                                |  1 +
 ...antiation_inherits_parent_branch_quota.zig | 30 -------------------
 2 files changed, 1 insertion(+), 30 deletions(-)
 delete mode 100644 test/cases/compile_errors/generic_funciton_instantiation_inherits_parent_branch_quota.zig

diff --git a/src/Module.zig b/src/Module.zig
index 9a395d72c4..a8ea63ffc9 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -3489,6 +3489,7 @@ pub fn destroyDecl(mod: *Module, decl_index: Decl.Index) void {
                 const errs = mod.comp.getAllErrorsAlloc() catch break :blk;
                 for (errs.list) |err| Compilation.AllErrors.Message.renderToStdErr(err, .no_color);
             }
+            // TODO restore test case triggering this panic
             @panic("Zig compiler bug: attempted to destroy declaration with an attached error");
         }
         const decl = mod.declPtr(decl_index);
diff --git a/test/cases/compile_errors/generic_funciton_instantiation_inherits_parent_branch_quota.zig b/test/cases/compile_errors/generic_funciton_instantiation_inherits_parent_branch_quota.zig
deleted file mode 100644
index 1d45ce86db..0000000000
--- a/test/cases/compile_errors/generic_funciton_instantiation_inherits_parent_branch_quota.zig
+++ /dev/null
@@ -1,30 +0,0 @@
-pub export fn entry1() void {
-    @setEvalBranchQuota(1001);
-    // Return type evaluation should inherit both the
-    // parent's branch quota and count meaning
-    // at least 2002 backwards branches are required.
-    comptime var i = 0;
-    inline while (i < 1000) : (i += 1) {}
-    _ = simple(10);
-}
-pub export fn entry2() void {
-    @setEvalBranchQuota(2001);
-    comptime var i = 0;
-    inline while (i < 1000) : (i += 1) {}
-    _ = simple(10);
-}
-fn simple(comptime n: usize) Type(n) {
-    return n;
-}
-fn Type(comptime n: usize) type {
-    if (n <= 1) return usize;
-    return Type(n - 1);
-}
-
-// error
-// backend=stage2
-// target=native
-//
-// :21:16: error: evaluation exceeded 1001 backwards branches
-// :21:16: note: use @setEvalBranchQuota() to raise the branch limit from 1001
-// :16:34: note: called from here

From dd437ae39948031dc04836f245c8b77d459a428a Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 24 Oct 2022 14:41:22 +0300
Subject: [PATCH 29/70] stage2: optimize size of optional slices

---
 src/codegen/c.zig          | 14 +++++++-----
 src/codegen/llvm.zig       | 10 +++++++--
 src/type.zig               | 46 +++++++-------------------------------
 test/behavior/cast.zig     |  4 ++++
 test/behavior/optional.zig | 16 +++++++++++++
 5 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index d6584d75ae..5f6f2fd6d5 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -726,7 +726,11 @@ pub const DeclGen = struct {
                 }
 
                 if (ty.optionalReprIsPayload()) {
-                    return dg.renderValue(writer, payload_ty, val, location);
+                    if (val.castTag(.opt_payload)) |payload| {
+                        return dg.renderValue(writer, payload_ty, payload.data, location);
+                    } else {
+                        return dg.renderValue(writer, payload_ty, val, location);
+                    }
                 }
 
                 try writer.writeByte('(');
@@ -3263,11 +3267,9 @@ fn airIsNull(
     try f.writeCValue(writer, operand);
 
     const ty = f.air.typeOf(un_op);
+    const opt_ty = if (deref_suffix[0] != 0) ty.childType() else ty;
     var opt_buf: Type.Payload.ElemType = undefined;
-    const payload_ty = if (deref_suffix[0] != 0)
-        ty.childType().optionalChild(&opt_buf)
-    else
-        ty.optionalChild(&opt_buf);
+    const payload_ty = opt_ty.optionalChild(&opt_buf);
 
     if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
         try writer.print("){s} {s} true;\n", .{ deref_suffix, operator });
@@ -3276,6 +3278,8 @@ fn airIsNull(
         try writer.print("){s} {s} NULL;\n", .{ deref_suffix, operator });
     } else if (payload_ty.zigTypeTag() == .ErrorSet) {
         try writer.print("){s} {s} 0;\n", .{ deref_suffix, operator });
+    } else if (payload_ty.isSlice() and opt_ty.optionalReprIsPayload()) {
+        try writer.print("){s}.ptr {s} NULL;\n", .{ deref_suffix, operator });
     } else {
         try writer.print("){s}.is_null {s} true;\n", .{ deref_suffix, operator });
     }
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index ffc19cb6f6..d4a94d1308 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -6316,18 +6316,24 @@ pub const FuncGen = struct {
         const operand_ty = self.air.typeOf(un_op);
         const optional_ty = if (operand_is_ptr) operand_ty.childType() else operand_ty;
         const optional_llvm_ty = try self.dg.lowerType(optional_ty);
+        var buf: Type.Payload.ElemType = undefined;
+        const payload_ty = optional_ty.optionalChild(&buf);
         if (optional_ty.optionalReprIsPayload()) {
             const loaded = if (operand_is_ptr)
                 self.builder.buildLoad(optional_llvm_ty, operand, "")
             else
                 operand;
+            if (payload_ty.isSlice()) {
+                const slice_ptr = self.builder.buildExtractValue(loaded, 0, "");
+                var slice_buf: Type.SlicePtrFieldTypeBuffer = undefined;
+                const ptr_ty = try self.dg.lowerType(payload_ty.slicePtrFieldType(&slice_buf));
+                return self.builder.buildICmp(pred, slice_ptr, ptr_ty.constNull(), "");
+            }
             return self.builder.buildICmp(pred, loaded, optional_llvm_ty.constNull(), "");
         }
 
         comptime assert(optional_layout_version == 3);
 
-        var buf: Type.Payload.ElemType = undefined;
-        const payload_ty = optional_ty.optionalChild(&buf);
         if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
             const loaded = if (operand_is_ptr)
                 self.builder.buildLoad(optional_llvm_ty, operand, "")
diff --git a/src/type.zig b/src/type.zig
index a2f0bb9e8f..8904b3178d 100644
--- a/src/type.zig
+++ b/src/type.zig
@@ -3469,20 +3469,8 @@ pub const Type = extern union {
 
                 if (!child_type.hasRuntimeBits()) return AbiSizeAdvanced{ .scalar = 1 };
 
-                switch (child_type.zigTypeTag()) {
-                    .Pointer => {
-                        const ptr_info = child_type.ptrInfo().data;
-                        const has_null = switch (ptr_info.size) {
-                            .Slice, .C => true,
-                            else => ptr_info.@"allowzero",
-                        };
-                        if (!has_null) {
-                            const ptr_size_bytes = @divExact(target.cpu.arch.ptrBitWidth(), 8);
-                            return AbiSizeAdvanced{ .scalar = ptr_size_bytes };
-                        }
-                    },
-                    .ErrorSet => return abiSizeAdvanced(Type.anyerror, target, strat),
-                    else => {},
+                if (ty.optionalReprIsPayload()) {
+                    return abiSizeAdvanced(child_type, target, strat);
                 }
 
                 const payload_size = switch (try child_type.abiSizeAdvanced(target, strat)) {
@@ -3747,28 +3735,10 @@ pub const Type = extern union {
 
             .int_signed, .int_unsigned => return ty.cast(Payload.Bits).?.data,
 
-            .optional => {
-                var buf: Payload.ElemType = undefined;
-                const child_type = ty.optionalChild(&buf);
-                if (!child_type.hasRuntimeBits()) return 8;
-
-                if (child_type.zigTypeTag() == .Pointer and !child_type.isCPtr() and !child_type.isSlice())
-                    return target.cpu.arch.ptrBitWidth();
-
-                // Optional types are represented as a struct with the child type as the first
-                // field and a boolean as the second. Since the child type's abi alignment is
-                // guaranteed to be >= that of bool's (1 byte) the added size is exactly equal
-                // to the child type's ABI alignment.
-                const child_bit_size = try bitSizeAdvanced(child_type, target, sema_kit);
-                return child_bit_size + 1;
-            },
-
-            .error_union => {
-                const payload = ty.castTag(.error_union).?.data;
-                if (!payload.payload.hasRuntimeBits()) {
-                    return payload.error_set.bitSizeAdvanced(target, sema_kit);
-                }
-                @panic("TODO bitSize error union");
+            .optional, .error_union => {
+                // Optionals and error unions are not packed so their bitsize
+                // includes padding bits.
+                return (try abiSizeAdvanced(ty, target, if (sema_kit) |sk| .{ .sema_kit = sk } else .eager)).scalar * 8;
             },
 
             .atomic_order,
@@ -4045,8 +4015,8 @@ pub const Type = extern union {
                     .Pointer => {
                         const info = child_ty.ptrInfo().data;
                         switch (info.size) {
-                            .Slice, .C => return false,
-                            .Many, .One => return !info.@"allowzero",
+                            .C => return false,
+                            .Slice, .Many, .One => return !info.@"allowzero",
                         }
                     },
                     .ErrorSet => return true,
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index 9a02e74853..cb76f86820 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -1170,6 +1170,7 @@ test "implicitly cast from [N]T to ?[]const T" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
 
     try expect(mem.eql(u8, castToOptionalSlice().?, "hi"));
     comptime try expect(mem.eql(u8, castToOptionalSlice().?, "hi"));
@@ -1256,6 +1257,7 @@ test "*const [N]null u8 to ?[]const u8" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
 
     const S = struct {
         fn doTheTest() !void {
@@ -1394,6 +1396,8 @@ test "cast i8 fn call peers to i32 result" {
 test "cast compatible optional types" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
 
     var a: ?[:0]const u8 = null;
     var b: ?[]const u8 = a;
diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig
index eb693147e6..9c9211f777 100644
--- a/test/behavior/optional.zig
+++ b/test/behavior/optional.zig
@@ -3,6 +3,7 @@ const std = @import("std");
 const testing = std.testing;
 const expect = testing.expect;
 const expectEqual = testing.expectEqual;
+const expectEqualStrings = std.testing.expectEqualStrings;
 
 test "passing an optional integer as a parameter" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
@@ -428,3 +429,18 @@ test "alignment of wrapping an optional payload" {
     };
     try expect(S.foo().?.x == 1234);
 }
+
+test "Optional slice size is optimized" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+
+    try expect(@sizeOf(?[]u8) == @sizeOf([]u8));
+    var a: ?[]const u8 = null;
+    try expect(a == null);
+    a = "hello";
+    try expectEqualStrings(a.?, "hello");
+}

From 78a7bb108ad9f7bf59061675bcae8947d65afc3a Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 24 Oct 2022 14:46:14 +0300
Subject: [PATCH 30/70] llvm: handle namespace like packed structs

Closes #13159
Closes #13188
---
 src/codegen/llvm.zig         |  2 +-
 test/behavior.zig            |  1 +
 test/behavior/bugs/13159.zig | 14 ++++++++++++++
 3 files changed, 16 insertions(+), 1 deletion(-)
 create mode 100644 test/behavior/bugs/13159.zig

diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index d4a94d1308..18b89eef78 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -1916,7 +1916,7 @@ pub const Object = struct {
 
                 if (ty.castTag(.@"struct")) |payload| {
                     const struct_obj = payload.data;
-                    if (struct_obj.layout == .Packed) {
+                    if (struct_obj.layout == .Packed and struct_obj.haveFieldTypes()) {
                         const info = struct_obj.backing_int_ty.intInfo(target);
                         const dwarf_encoding: c_uint = switch (info.signedness) {
                             .signed => DW.ATE.signed,
diff --git a/test/behavior.zig b/test/behavior.zig
index 2f5d752087..442b27c09f 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -109,6 +109,7 @@ test {
     _ = @import("behavior/bugs/13128.zig");
     _ = @import("behavior/bugs/13164.zig");
     _ = @import("behavior/bugs/13171.zig");
+    _ = @import("behavior/bugs/13159.zig");
     _ = @import("behavior/byteswap.zig");
     _ = @import("behavior/byval_arg_var.zig");
     _ = @import("behavior/call.zig");
diff --git a/test/behavior/bugs/13159.zig b/test/behavior/bugs/13159.zig
new file mode 100644
index 0000000000..6119c498a9
--- /dev/null
+++ b/test/behavior/bugs/13159.zig
@@ -0,0 +1,14 @@
+const std = @import("std");
+const expect = std.testing.expect;
+
+const Bar = packed struct {
+    const Baz = enum {
+        fizz,
+        buzz,
+    };
+};
+
+test {
+    var foo = Bar.Baz.fizz;
+    try expect(foo == .fizz);
+}

From d773b7e71f8d9fd3d69c1f90cec9a941fc9f9a12 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 24 Oct 2022 15:16:25 +0300
Subject: [PATCH 31/70] translate-c: cleanup unused parameters

---
 src/translate_c.zig | 182 ++++++++++++++++++--------------------------
 1 file changed, 75 insertions(+), 107 deletions(-)

diff --git a/src/translate_c.zig b/src/translate_c.zig
index d71e5f30e2..219635859c 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -224,8 +224,7 @@ const Scope = struct {
         }
     }
 
-    fn findBlockReturnType(inner: *Scope, c: *Context) clang.QualType {
-        _ = c;
+    fn findBlockReturnType(inner: *Scope) clang.QualType {
         var scope = inner;
         while (true) {
             switch (scope.id) {
@@ -833,7 +832,7 @@ fn visitVarDecl(c: *Context, var_decl: *const clang.VarDecl, mangled_name: ?[]co
     if (has_init) trans_init: {
         if (decl_init) |expr| {
             const node_or_error = if (expr.getStmtClass() == .StringLiteralClass)
-                transStringLiteralInitializer(c, scope, @ptrCast(*const clang.StringLiteral, expr), type_node)
+                transStringLiteralInitializer(c, @ptrCast(*const clang.StringLiteral, expr), type_node)
             else
                 transExprCoercing(c, scope, expr, .used);
             init_node = node_or_error catch |err| switch (err) {
@@ -1319,10 +1318,10 @@ fn transStmt(
         .StringLiteralClass => return transStringLiteral(c, scope, @ptrCast(*const clang.StringLiteral, stmt), result_used),
         .ParenExprClass => {
             const expr = try transExpr(c, scope, @ptrCast(*const clang.ParenExpr, stmt).getSubExpr(), .used);
-            return maybeSuppressResult(c, scope, result_used, expr);
+            return maybeSuppressResult(c, result_used, expr);
         },
         .InitListExprClass => return transInitListExpr(c, scope, @ptrCast(*const clang.InitListExpr, stmt), result_used),
-        .ImplicitValueInitExprClass => return transImplicitValueInitExpr(c, scope, @ptrCast(*const clang.Expr, stmt), result_used),
+        .ImplicitValueInitExprClass => return transImplicitValueInitExpr(c, scope, @ptrCast(*const clang.Expr, stmt)),
         .IfStmtClass => return transIfStmt(c, scope, @ptrCast(*const clang.IfStmt, stmt)),
         .WhileStmtClass => return transWhileLoop(c, scope, @ptrCast(*const clang.WhileStmt, stmt)),
         .DoStmtClass => return transDoWhileLoop(c, scope, @ptrCast(*const clang.DoStmt, stmt)),
@@ -1332,7 +1331,7 @@ fn transStmt(
         .ContinueStmtClass => return Tag.@"continue".init(),
         .BreakStmtClass => return Tag.@"break".init(),
         .ForStmtClass => return transForLoop(c, scope, @ptrCast(*const clang.ForStmt, stmt)),
-        .FloatingLiteralClass => return transFloatingLiteral(c, scope, @ptrCast(*const clang.FloatingLiteral, stmt), result_used),
+        .FloatingLiteralClass => return transFloatingLiteral(c, @ptrCast(*const clang.FloatingLiteral, stmt), result_used),
         .ConditionalOperatorClass => {
             return transConditionalOperator(c, scope, @ptrCast(*const clang.ConditionalOperator, stmt), result_used);
         },
@@ -1356,9 +1355,9 @@ fn transStmt(
         .OpaqueValueExprClass => {
             const source_expr = @ptrCast(*const clang.OpaqueValueExpr, stmt).getSourceExpr().?;
             const expr = try transExpr(c, scope, source_expr, .used);
-            return maybeSuppressResult(c, scope, result_used, expr);
+            return maybeSuppressResult(c, result_used, expr);
         },
-        .OffsetOfExprClass => return transOffsetOfExpr(c, scope, @ptrCast(*const clang.OffsetOfExpr, stmt), result_used),
+        .OffsetOfExprClass => return transOffsetOfExpr(c, @ptrCast(*const clang.OffsetOfExpr, stmt), result_used),
         .CompoundLiteralExprClass => {
             const compound_literal = @ptrCast(*const clang.CompoundLiteralExpr, stmt);
             return transExpr(c, scope, compound_literal.getInitializer(), result_used);
@@ -1369,13 +1368,13 @@ fn transStmt(
         },
         .ConvertVectorExprClass => {
             const conv_vec = @ptrCast(*const clang.ConvertVectorExpr, stmt);
-            const conv_vec_node = try transConvertVectorExpr(c, scope, stmt.getBeginLoc(), conv_vec);
-            return maybeSuppressResult(c, scope, result_used, conv_vec_node);
+            const conv_vec_node = try transConvertVectorExpr(c, scope, conv_vec);
+            return maybeSuppressResult(c, result_used, conv_vec_node);
         },
         .ShuffleVectorExprClass => {
             const shuffle_vec_expr = @ptrCast(*const clang.ShuffleVectorExpr, stmt);
             const shuffle_vec_node = try transShuffleVectorExpr(c, scope, shuffle_vec_expr);
-            return maybeSuppressResult(c, scope, result_used, shuffle_vec_node);
+            return maybeSuppressResult(c, result_used, shuffle_vec_node);
         },
         .ChooseExprClass => {
             const choose_expr = @ptrCast(*const clang.ChooseExpr, stmt);
@@ -1402,10 +1401,8 @@ fn transStmt(
 fn transConvertVectorExpr(
     c: *Context,
     scope: *Scope,
-    source_loc: clang.SourceLocation,
     expr: *const clang.ConvertVectorExpr,
 ) TransError!Node {
-    _ = source_loc;
     const base_stmt = @ptrCast(*const clang.Stmt, expr);
 
     var block_scope = try Scope.Block.init(c, scope, true);
@@ -1521,12 +1518,7 @@ fn transShuffleVectorExpr(
 
 /// Translate a "simple" offsetof expression containing exactly one component,
 /// when that component is of kind .Field - e.g. offsetof(mytype, myfield)
-fn transSimpleOffsetOfExpr(
-    c: *Context,
-    scope: *Scope,
-    expr: *const clang.OffsetOfExpr,
-) TransError!Node {
-    _ = scope;
+fn transSimpleOffsetOfExpr(c: *Context, expr: *const clang.OffsetOfExpr) TransError!Node {
     assert(expr.getNumComponents() == 1);
     const component = expr.getComponent(0);
     if (component.getKind() == .Field) {
@@ -1551,13 +1543,12 @@ fn transSimpleOffsetOfExpr(
 
 fn transOffsetOfExpr(
     c: *Context,
-    scope: *Scope,
     expr: *const clang.OffsetOfExpr,
     result_used: ResultUsed,
 ) TransError!Node {
     if (expr.getNumComponents() == 1) {
-        const offsetof_expr = try transSimpleOffsetOfExpr(c, scope, expr);
-        return maybeSuppressResult(c, scope, result_used, offsetof_expr);
+        const offsetof_expr = try transSimpleOffsetOfExpr(c, expr);
+        return maybeSuppressResult(c, result_used, offsetof_expr);
     }
 
     // TODO implement OffsetOfExpr with more than 1 component
@@ -1613,7 +1604,6 @@ fn transCreatePointerArithmeticSignedOp(
 
     return transCreateNodeInfixOp(
         c,
-        scope,
         if (is_add) .add else .sub,
         lhs_node,
         bitcast_node,
@@ -1629,7 +1619,7 @@ fn transBinaryOperator(
 ) TransError!Node {
     const op = stmt.getOpcode();
     const qt = stmt.getType();
-    const isPointerDiffExpr = cIsPointerDiffExpr(c, stmt);
+    const isPointerDiffExpr = cIsPointerDiffExpr(stmt);
     switch (op) {
         .Assign => return try transCreateNodeAssign(c, scope, result_used, stmt.getLHS(), stmt.getRHS()),
         .Comma => {
@@ -1646,7 +1636,7 @@ fn transBinaryOperator(
             });
             try block_scope.statements.append(break_node);
             const block_node = try block_scope.complete(c);
-            return maybeSuppressResult(c, scope, result_used, block_node);
+            return maybeSuppressResult(c, result_used, block_node);
         },
         .Div => {
             if (cIsSignedInteger(qt)) {
@@ -1654,7 +1644,7 @@ fn transBinaryOperator(
                 const lhs = try transExpr(c, scope, stmt.getLHS(), .used);
                 const rhs = try transExpr(c, scope, stmt.getRHS(), .used);
                 const div_trunc = try Tag.div_trunc.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
-                return maybeSuppressResult(c, scope, result_used, div_trunc);
+                return maybeSuppressResult(c, result_used, div_trunc);
             }
         },
         .Rem => {
@@ -1663,7 +1653,7 @@ fn transBinaryOperator(
                 const lhs = try transExpr(c, scope, stmt.getLHS(), .used);
                 const rhs = try transExpr(c, scope, stmt.getRHS(), .used);
                 const rem = try Tag.signed_remainder.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
-                return maybeSuppressResult(c, scope, result_used, rem);
+                return maybeSuppressResult(c, result_used, rem);
             }
         },
         .Shl => {
@@ -1764,7 +1754,7 @@ fn transBinaryOperator(
     else
         rhs_uncasted;
 
-    const infixOpNode = try transCreateNodeInfixOp(c, scope, op_id, lhs, rhs, result_used);
+    const infixOpNode = try transCreateNodeInfixOp(c, op_id, lhs, rhs, result_used);
     if (isPointerDiffExpr) {
         // @divExact(@bitCast(<platform-ptrdiff_t>, @ptrToInt(lhs) -% @ptrToInt(rhs)), @sizeOf(<lhs target type>))
         const ptrdiff_type = try transQualTypeIntWidthOf(c, qt, true);
@@ -1843,7 +1833,7 @@ fn transCStyleCastExprClass(
         src_type,
         sub_expr_node,
     ));
-    return maybeSuppressResult(c, scope, result_used, cast_node);
+    return maybeSuppressResult(c, result_used, cast_node);
 }
 
 /// The alignment of a variable or field
@@ -1933,7 +1923,7 @@ fn transDeclStmtOne(
 
             var init_node = if (decl_init) |expr|
                 if (expr.getStmtClass() == .StringLiteralClass)
-                    try transStringLiteralInitializer(c, scope, @ptrCast(*const clang.StringLiteral, expr), type_node)
+                    try transStringLiteralInitializer(c, @ptrCast(*const clang.StringLiteral, expr), type_node)
                 else
                     try transExprCoercing(c, scope, expr, .used)
             else if (is_static_local)
@@ -2051,21 +2041,21 @@ fn transImplicitCastExpr(
         .BitCast, .FloatingCast, .FloatingToIntegral, .IntegralToFloating, .IntegralCast, .PointerToIntegral, .IntegralToPointer => {
             const sub_expr_node = try transExpr(c, scope, sub_expr, .used);
             const casted = try transCCast(c, scope, expr.getBeginLoc(), dest_type, src_type, sub_expr_node);
-            return maybeSuppressResult(c, scope, result_used, casted);
+            return maybeSuppressResult(c, result_used, casted);
         },
         .LValueToRValue, .NoOp, .FunctionToPointerDecay => {
             const sub_expr_node = try transExpr(c, scope, sub_expr, .used);
-            return maybeSuppressResult(c, scope, result_used, sub_expr_node);
+            return maybeSuppressResult(c, result_used, sub_expr_node);
         },
         .ArrayToPointerDecay => {
             const sub_expr_node = try transExpr(c, scope, sub_expr, .used);
             if (exprIsNarrowStringLiteral(sub_expr) or exprIsFlexibleArrayRef(c, sub_expr)) {
-                return maybeSuppressResult(c, scope, result_used, sub_expr_node);
+                return maybeSuppressResult(c, result_used, sub_expr_node);
             }
 
             const addr = try Tag.address_of.create(c.arena, sub_expr_node);
             const casted = try transCPtrCast(c, scope, expr.getBeginLoc(), dest_type, src_type, addr);
-            return maybeSuppressResult(c, scope, result_used, casted);
+            return maybeSuppressResult(c, result_used, casted);
         },
         .NullToPointer => {
             return Tag.null_literal.init();
@@ -2076,18 +2066,18 @@ fn transImplicitCastExpr(
             const ptr_to_int = try Tag.ptr_to_int.create(c.arena, ptr_node);
 
             const ne = try Tag.not_equal.create(c.arena, .{ .lhs = ptr_to_int, .rhs = Tag.zero_literal.init() });
-            return maybeSuppressResult(c, scope, result_used, ne);
+            return maybeSuppressResult(c, result_used, ne);
         },
         .IntegralToBoolean, .FloatingToBoolean => {
             const sub_expr_node = try transExpr(c, scope, sub_expr, .used);
 
             // The expression is already a boolean one, return it as-is
             if (isBoolRes(sub_expr_node))
-                return maybeSuppressResult(c, scope, result_used, sub_expr_node);
+                return maybeSuppressResult(c, result_used, sub_expr_node);
 
             // val != 0
             const ne = try Tag.not_equal.create(c.arena, .{ .lhs = sub_expr_node, .rhs = Tag.zero_literal.init() });
-            return maybeSuppressResult(c, scope, result_used, ne);
+            return maybeSuppressResult(c, result_used, ne);
         },
         .BuiltinFnToFnPtr => {
             return transBuiltinFnExpr(c, scope, sub_expr, result_used);
@@ -2140,13 +2130,13 @@ fn transBoolExpr(
 
     var res = try transExpr(c, scope, expr, used);
     if (isBoolRes(res)) {
-        return maybeSuppressResult(c, scope, used, res);
+        return maybeSuppressResult(c, used, res);
     }
 
     const ty = getExprQualType(c, expr).getTypePtr();
     const node = try finishBoolExpr(c, scope, expr.getBeginLoc(), ty, res, used);
 
-    return maybeSuppressResult(c, scope, used, node);
+    return maybeSuppressResult(c, used, node);
 }
 
 fn exprIsBooleanType(expr: *const clang.Expr) bool {
@@ -2299,7 +2289,7 @@ fn transIntegerLiteral(
 
     if (suppress_as == .no_as) {
         const int_lit_node = try transCreateNodeAPInt(c, eval_result.Val.getInt());
-        return maybeSuppressResult(c, scope, result_used, int_lit_node);
+        return maybeSuppressResult(c, result_used, int_lit_node);
     }
 
     // Integer literals in C have types, and this can matter for several reasons.
@@ -2317,7 +2307,7 @@ fn transIntegerLiteral(
     const ty_node = try transQualType(c, scope, expr_base.getType(), expr_base.getBeginLoc());
     const rhs = try transCreateNodeAPInt(c, eval_result.Val.getInt());
     const as = try Tag.as.create(c.arena, .{ .lhs = ty_node, .rhs = rhs });
-    return maybeSuppressResult(c, scope, result_used, as);
+    return maybeSuppressResult(c, result_used, as);
 }
 
 fn transReturnStmt(
@@ -2329,7 +2319,7 @@ fn transReturnStmt(
         return Tag.return_void.init();
 
     var rhs = try transExprCoercing(c, scope, val_expr, .used);
-    const return_qt = scope.findBlockReturnType(c);
+    const return_qt = scope.findBlockReturnType();
     if (isBoolRes(rhs) and !qualTypeIsBoolean(return_qt)) {
         rhs = try Tag.bool_to_int.create(c.arena, rhs);
     }
@@ -2338,7 +2328,6 @@ fn transReturnStmt(
 
 fn transNarrowStringLiteral(
     c: *Context,
-    scope: *Scope,
     stmt: *const clang.StringLiteral,
     result_used: ResultUsed,
 ) TransError!Node {
@@ -2347,7 +2336,7 @@ fn transNarrowStringLiteral(
 
     const str = try std.fmt.allocPrint(c.arena, "\"{}\"", .{std.zig.fmtEscapes(bytes_ptr[0..len])});
     const node = try Tag.string_literal.create(c.arena, str);
-    return maybeSuppressResult(c, scope, result_used, node);
+    return maybeSuppressResult(c, result_used, node);
 }
 
 fn transStringLiteral(
@@ -2358,18 +2347,18 @@ fn transStringLiteral(
 ) TransError!Node {
     const kind = stmt.getKind();
     switch (kind) {
-        .Ascii, .UTF8 => return transNarrowStringLiteral(c, scope, stmt, result_used),
+        .Ascii, .UTF8 => return transNarrowStringLiteral(c, stmt, result_used),
         .UTF16, .UTF32, .Wide => {
             const str_type = @tagName(stmt.getKind());
             const name = try std.fmt.allocPrint(c.arena, "zig.{s}_string_{d}", .{ str_type, c.getMangle() });
 
             const expr_base = @ptrCast(*const clang.Expr, stmt);
             const array_type = try transQualTypeInitialized(c, scope, expr_base.getType(), expr_base, expr_base.getBeginLoc());
-            const lit_array = try transStringLiteralInitializer(c, scope, stmt, array_type);
+            const lit_array = try transStringLiteralInitializer(c, stmt, array_type);
             const decl = try Tag.var_simple.create(c.arena, .{ .name = name, .init = lit_array });
             try scope.appendNode(decl);
             const node = try Tag.identifier.create(c.arena, name);
-            return maybeSuppressResult(c, scope, result_used, node);
+            return maybeSuppressResult(c, result_used, node);
         },
     }
 }
@@ -2384,7 +2373,6 @@ fn getArrayPayload(array_type: Node) ast.Payload.Array.ArrayTypeInfo {
 /// the appropriate length, if necessary.
 fn transStringLiteralInitializer(
     c: *Context,
-    scope: *Scope,
     stmt: *const clang.StringLiteral,
     array_type: Node,
 ) TransError!Node {
@@ -2403,7 +2391,7 @@ fn transStringLiteralInitializer(
     const init_node = if (num_inits > 0) blk: {
         if (is_narrow) {
             // "string literal".* or string literal"[0..num_inits].*
-            var str = try transNarrowStringLiteral(c, scope, stmt, .used);
+            var str = try transNarrowStringLiteral(c, stmt, .used);
             if (str_length != array_size) str = try Tag.string_slice.create(c.arena, .{ .string = str, .end = num_inits });
             break :blk try Tag.deref.create(c.arena, str);
         } else {
@@ -2440,8 +2428,7 @@ fn transStringLiteralInitializer(
 /// determine whether `stmt` is a "pointer subtraction expression" - a subtraction where
 /// both operands resolve to addresses. The C standard requires that both operands
 /// point to elements of the same array object, but we do not verify that here.
-fn cIsPointerDiffExpr(c: *Context, stmt: *const clang.BinaryOperator) bool {
-    _ = c;
+fn cIsPointerDiffExpr(stmt: *const clang.BinaryOperator) bool {
     const lhs = @ptrCast(*const clang.Stmt, stmt.getLHS());
     const rhs = @ptrCast(*const clang.Stmt, stmt.getRHS());
     return stmt.getOpcode() == .Sub and
@@ -2748,9 +2735,7 @@ fn transInitListExprVector(
     scope: *Scope,
     loc: clang.SourceLocation,
     expr: *const clang.InitListExpr,
-    ty: *const clang.Type,
 ) TransError!Node {
-    _ = ty;
     const qt = getExprQualType(c, @ptrCast(*const clang.Expr, expr));
     const vector_ty = @ptrCast(*const clang.VectorType, qualTypeCanon(qt));
 
@@ -2829,7 +2814,7 @@ fn transInitListExpr(
     }
 
     if (qual_type.isRecordType()) {
-        return maybeSuppressResult(c, scope, used, try transInitListExprRecord(
+        return maybeSuppressResult(c, used, try transInitListExprRecord(
             c,
             scope,
             source_loc,
@@ -2837,7 +2822,7 @@ fn transInitListExpr(
             qual_type,
         ));
     } else if (qual_type.isArrayType()) {
-        return maybeSuppressResult(c, scope, used, try transInitListExprArray(
+        return maybeSuppressResult(c, used, try transInitListExprArray(
             c,
             scope,
             source_loc,
@@ -2845,13 +2830,7 @@ fn transInitListExpr(
             qual_type,
         ));
     } else if (qual_type.isVectorType()) {
-        return maybeSuppressResult(c, scope, used, try transInitListExprVector(
-            c,
-            scope,
-            source_loc,
-            expr,
-            qual_type,
-        ));
+        return maybeSuppressResult(c, used, try transInitListExprVector(c, scope, source_loc, expr));
     } else {
         const type_name = try c.str(qual_type.getTypeClassName());
         return fail(c, error.UnsupportedType, source_loc, "unsupported initlist type: '{s}'", .{type_name});
@@ -2912,9 +2891,7 @@ fn transImplicitValueInitExpr(
     c: *Context,
     scope: *Scope,
     expr: *const clang.Expr,
-    used: ResultUsed,
 ) TransError!Node {
-    _ = used;
     const source_loc = expr.getBeginLoc();
     const qt = getExprQualType(c, expr);
     const ty = qt.getTypePtr();
@@ -3354,7 +3331,7 @@ fn transConstantExpr(c: *Context, scope: *Scope, expr: *const clang.Expr, used:
                 .lhs = try transQualType(c, scope, expr_base.getType(), expr_base.getBeginLoc()),
                 .rhs = try transCreateNodeAPInt(c, result.Val.getInt()),
             });
-            return maybeSuppressResult(c, scope, used, as_node);
+            return maybeSuppressResult(c, used, as_node);
         },
         else => |kind| {
             return fail(c, error.UnsupportedTranslation, expr.getBeginLoc(), "unsupported constant expression kind '{}'", .{kind});
@@ -3391,7 +3368,7 @@ fn transCharLiteral(
         try transCreateCharLitNode(c, narrow, val);
 
     if (suppress_as == .no_as) {
-        return maybeSuppressResult(c, scope, result_used, int_lit_node);
+        return maybeSuppressResult(c, result_used, int_lit_node);
     }
     // See comment in `transIntegerLiteral` for why this code is here.
     // @as(T, x)
@@ -3400,7 +3377,7 @@ fn transCharLiteral(
         .lhs = try transQualType(c, scope, expr_base.getType(), expr_base.getBeginLoc()),
         .rhs = int_lit_node,
     });
-    return maybeSuppressResult(c, scope, result_used, as_node);
+    return maybeSuppressResult(c, result_used, as_node);
 }
 
 fn transStmtExpr(c: *Context, scope: *Scope, stmt: *const clang.StmtExpr, used: ResultUsed) TransError!Node {
@@ -3426,7 +3403,7 @@ fn transStmtExpr(c: *Context, scope: *Scope, stmt: *const clang.StmtExpr, used:
     });
     try block_scope.statements.append(break_node);
     const res = try block_scope.complete(c);
-    return maybeSuppressResult(c, scope, used, res);
+    return maybeSuppressResult(c, used, res);
 }
 
 fn transMemberExpr(c: *Context, scope: *Scope, stmt: *const clang.MemberExpr, result_used: ResultUsed) TransError!Node {
@@ -3455,7 +3432,7 @@ fn transMemberExpr(c: *Context, scope: *Scope, stmt: *const clang.MemberExpr, re
     if (exprIsFlexibleArrayRef(c, @ptrCast(*const clang.Expr, stmt))) {
         node = try Tag.call.create(c.arena, .{ .lhs = node, .args = &.{} });
     }
-    return maybeSuppressResult(c, scope, result_used, node);
+    return maybeSuppressResult(c, result_used, node);
 }
 
 /// ptr[subscr] (`subscr` is a signed integer expression, `ptr` a pointer) becomes:
@@ -3533,7 +3510,7 @@ fn transSignedArrayAccess(
 
     const derefed = try Tag.deref.create(c.arena, block_node);
 
-    return maybeSuppressResult(c, &block_scope.base, result_used, derefed);
+    return maybeSuppressResult(c, result_used, derefed);
 }
 
 fn transArrayAccess(c: *Context, scope: *Scope, stmt: *const clang.ArraySubscriptExpr, result_used: ResultUsed) TransError!Node {
@@ -3574,7 +3551,7 @@ fn transArrayAccess(c: *Context, scope: *Scope, stmt: *const clang.ArraySubscrip
         .lhs = container_node,
         .rhs = rhs,
     });
-    return maybeSuppressResult(c, scope, result_used, node);
+    return maybeSuppressResult(c, result_used, node);
 }
 
 /// Check if an expression is ultimately a reference to a function declaration
@@ -3665,7 +3642,7 @@ fn transCallExpr(c: *Context, scope: *Scope, stmt: *const clang.CallExpr, result
         }
     }
 
-    return maybeSuppressResult(c, scope, result_used, node);
+    return maybeSuppressResult(c, result_used, node);
 }
 
 const ClangFunctionType = union(enum) {
@@ -3705,14 +3682,13 @@ fn transUnaryExprOrTypeTraitExpr(
     stmt: *const clang.UnaryExprOrTypeTraitExpr,
     result_used: ResultUsed,
 ) TransError!Node {
-    _ = result_used;
     const loc = stmt.getBeginLoc();
     const type_node = try transQualType(c, scope, stmt.getTypeOfArgument(), loc);
 
     const kind = stmt.getKind();
-    switch (kind) {
-        .SizeOf => return Tag.sizeof.create(c.arena, type_node),
-        .AlignOf => return Tag.alignof.create(c.arena, type_node),
+    const node = switch (kind) {
+        .SizeOf => try Tag.sizeof.create(c.arena, type_node),
+        .AlignOf => try Tag.alignof.create(c.arena, type_node),
         .PreferredAlignOf,
         .VecStep,
         .OpenMPRequiredSimdAlign,
@@ -3723,7 +3699,8 @@ fn transUnaryExprOrTypeTraitExpr(
             "unsupported type trait kind {}",
             .{kind},
         ),
-    }
+    };
+    return maybeSuppressResult(c, result_used, node);
 }
 
 fn qualTypeHasWrappingOverflow(qt: clang.QualType) bool {
@@ -3812,7 +3789,7 @@ fn transCreatePreCrement(
         // zig: expr += 1
         const lhs = try transExpr(c, scope, op_expr, .used);
         const rhs = Tag.one_literal.init();
-        return transCreateNodeInfixOp(c, scope, op, lhs, rhs, .used);
+        return transCreateNodeInfixOp(c, op, lhs, rhs, .used);
     }
     // worst case
     // c: ++expr
@@ -3832,7 +3809,7 @@ fn transCreatePreCrement(
 
     const lhs_node = try Tag.identifier.create(c.arena, ref);
     const ref_node = try Tag.deref.create(c.arena, lhs_node);
-    const node = try transCreateNodeInfixOp(c, &block_scope.base, op, ref_node, Tag.one_literal.init(), .used);
+    const node = try transCreateNodeInfixOp(c, op, ref_node, Tag.one_literal.init(), .used);
     try block_scope.statements.append(node);
 
     const break_node = try Tag.break_val.create(c.arena, .{
@@ -3858,7 +3835,7 @@ fn transCreatePostCrement(
         // zig: expr += 1
         const lhs = try transExpr(c, scope, op_expr, .used);
         const rhs = Tag.one_literal.init();
-        return transCreateNodeInfixOp(c, scope, op, lhs, rhs, .used);
+        return transCreateNodeInfixOp(c, op, lhs, rhs, .used);
     }
     // worst case
     // c: expr++
@@ -3884,7 +3861,7 @@ fn transCreatePostCrement(
     const tmp_decl = try Tag.var_simple.create(c.arena, .{ .name = tmp, .init = ref_node });
     try block_scope.statements.append(tmp_decl);
 
-    const node = try transCreateNodeInfixOp(c, &block_scope.base, op, ref_node, Tag.one_literal.init(), .used);
+    const node = try transCreateNodeInfixOp(c, op, ref_node, Tag.one_literal.init(), .used);
     try block_scope.statements.append(node);
 
     const break_node = try Tag.break_val.create(c.arena, .{
@@ -3965,7 +3942,7 @@ fn transCreateCompoundAssign(
             else
                 try Tag.div_trunc.create(c.arena, operands);
 
-            return transCreateNodeInfixOp(c, scope, .assign, lhs_node, builtin, .used);
+            return transCreateNodeInfixOp(c, .assign, lhs_node, builtin, .used);
         }
 
         if (is_shift) {
@@ -3974,7 +3951,7 @@ fn transCreateCompoundAssign(
         } else if (requires_int_cast) {
             rhs_node = try transCCast(c, scope, loc, lhs_qt, rhs_qt, rhs_node);
         }
-        return transCreateNodeInfixOp(c, scope, op, lhs_node, rhs_node, .used);
+        return transCreateNodeInfixOp(c, op, lhs_node, rhs_node, .used);
     }
     // worst case
     // c:   lhs += rhs
@@ -4005,7 +3982,7 @@ fn transCreateCompoundAssign(
         else
             try Tag.div_trunc.create(c.arena, operands);
 
-        const assign = try transCreateNodeInfixOp(c, &block_scope.base, .assign, ref_node, builtin, .used);
+        const assign = try transCreateNodeInfixOp(c, .assign, ref_node, builtin, .used);
         try block_scope.statements.append(assign);
     } else {
         if (is_shift) {
@@ -4015,7 +3992,7 @@ fn transCreateCompoundAssign(
             rhs_node = try transCCast(c, &block_scope.base, loc, lhs_qt, rhs_qt, rhs_node);
         }
 
-        const assign = try transCreateNodeInfixOp(c, &block_scope.base, op, ref_node, rhs_node, .used);
+        const assign = try transCreateNodeInfixOp(c, op, ref_node, rhs_node, .used);
         try block_scope.statements.append(assign);
     }
 
@@ -4071,7 +4048,7 @@ fn transCPtrCast(
     }
 }
 
-fn transFloatingLiteral(c: *Context, scope: *Scope, expr: *const clang.FloatingLiteral, used: ResultUsed) TransError!Node {
+fn transFloatingLiteral(c: *Context, expr: *const clang.FloatingLiteral, used: ResultUsed) TransError!Node {
     switch (expr.getRawSemantics()) {
         .IEEEhalf, // f16
         .IEEEsingle, // f32
@@ -4095,7 +4072,7 @@ fn transFloatingLiteral(c: *Context, scope: *Scope, expr: *const clang.FloatingL
         try std.fmt.allocPrint(c.arena, "{d}", .{dbl});
     var node = try Tag.float_literal.create(c.arena, str);
     if (is_negative) node = try Tag.negate.create(c.arena, node);
-    return maybeSuppressResult(c, scope, used, node);
+    return maybeSuppressResult(c, used, node);
 }
 
 fn transBinaryConditionalOperator(c: *Context, scope: *Scope, stmt: *const clang.BinaryConditionalOperator, used: ResultUsed) TransError!Node {
@@ -4151,7 +4128,7 @@ fn transBinaryConditionalOperator(c: *Context, scope: *Scope, stmt: *const clang
     });
     try block_scope.statements.append(break_node);
     const res = try block_scope.complete(c);
-    return maybeSuppressResult(c, scope, used, res);
+    return maybeSuppressResult(c, used, res);
 }
 
 fn transConditionalOperator(c: *Context, scope: *Scope, stmt: *const clang.ConditionalOperator, used: ResultUsed) TransError!Node {
@@ -4191,13 +4168,7 @@ fn transConditionalOperator(c: *Context, scope: *Scope, stmt: *const clang.Condi
     return if_node;
 }
 
-fn maybeSuppressResult(
-    c: *Context,
-    scope: *Scope,
-    used: ResultUsed,
-    result: Node,
-) TransError!Node {
-    _ = scope;
+fn maybeSuppressResult(c: *Context, used: ResultUsed, result: Node) TransError!Node {
     if (used == .used) return result;
     return Tag.discard.create(c.arena, .{ .should_skip = false, .value = result });
 }
@@ -4551,7 +4522,7 @@ fn transCreateNodeAssign(
         if (!exprIsBooleanType(lhs) and isBoolRes(rhs_node)) {
             rhs_node = try Tag.bool_to_int.create(c.arena, rhs_node);
         }
-        return transCreateNodeInfixOp(c, scope, .assign, lhs_node, rhs_node, .used);
+        return transCreateNodeInfixOp(c, .assign, lhs_node, rhs_node, .used);
     }
 
     // worst case
@@ -4571,7 +4542,7 @@ fn transCreateNodeAssign(
 
     const lhs_node = try transExpr(c, &block_scope.base, lhs, .used);
     const tmp_ident = try Tag.identifier.create(c.arena, tmp);
-    const assign = try transCreateNodeInfixOp(c, &block_scope.base, .assign, lhs_node, tmp_ident, .used);
+    const assign = try transCreateNodeInfixOp(c, .assign, lhs_node, tmp_ident, .used);
     try block_scope.statements.append(assign);
 
     const break_node = try Tag.break_val.create(c.arena, .{
@@ -4584,7 +4555,6 @@ fn transCreateNodeAssign(
 
 fn transCreateNodeInfixOp(
     c: *Context,
-    scope: *Scope,
     op: Tag,
     lhs: Node,
     rhs: Node,
@@ -4598,7 +4568,7 @@ fn transCreateNodeInfixOp(
             .rhs = rhs,
         },
     };
-    return maybeSuppressResult(c, scope, used, Node.initPayload(&payload.base));
+    return maybeSuppressResult(c, used, Node.initPayload(&payload.base));
 }
 
 fn transCreateNodeBoolInfixOp(
@@ -4613,7 +4583,7 @@ fn transCreateNodeBoolInfixOp(
     const lhs = try transBoolExpr(c, scope, stmt.getLHS(), .used);
     const rhs = try transBoolExpr(c, scope, stmt.getRHS(), .used);
 
-    return transCreateNodeInfixOp(c, scope, op, lhs, rhs, used);
+    return transCreateNodeInfixOp(c, op, lhs, rhs, used);
 }
 
 fn transCreateNodeAPInt(c: *Context, int: *const clang.APSInt) !Node {
@@ -4730,7 +4700,7 @@ fn transCreateNodeShiftOp(
     const rhs = try transExprCoercing(c, scope, rhs_expr, .used);
     const rhs_casted = try Tag.int_cast.create(c.arena, .{ .lhs = rhs_type, .rhs = rhs });
 
-    return transCreateNodeInfixOp(c, scope, op, lhs, rhs_casted, used);
+    return transCreateNodeInfixOp(c, op, lhs, rhs_casted, used);
 }
 
 fn transType(c: *Context, scope: *Scope, ty: *const clang.Type, source_loc: clang.SourceLocation) TypeError!Node {
@@ -6298,7 +6268,7 @@ fn parseCCastExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
 // allow_fail is set when unsure if we are parsing a type-name
 fn parseCTypeName(c: *Context, m: *MacroCtx, scope: *Scope, allow_fail: bool) ParseError!?Node {
     if (try parseCSpecifierQualifierList(c, m, scope, allow_fail)) |node| {
-        return try parseCAbstractDeclarator(c, m, scope, node);
+        return try parseCAbstractDeclarator(c, m, node);
     } else {
         return null;
     }
@@ -6327,7 +6297,7 @@ fn parseCSpecifierQualifierList(c: *Context, m: *MacroCtx, scope: *Scope, allow_
         .Keyword_complex,
         => {
             m.i -= 1;
-            return try parseCNumericType(c, m, scope);
+            return try parseCNumericType(c, m);
         },
         .Keyword_enum, .Keyword_struct, .Keyword_union => {
             // struct Foo will be declared as struct_Foo by transRecordDecl
@@ -6349,8 +6319,7 @@ fn parseCSpecifierQualifierList(c: *Context, m: *MacroCtx, scope: *Scope, allow_
     }
 }
 
-fn parseCNumericType(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
-    _ = scope;
+fn parseCNumericType(c: *Context, m: *MacroCtx) ParseError!Node {
     const KwCounter = struct {
         double: u8 = 0,
         long: u8 = 0,
@@ -6451,8 +6420,7 @@ fn parseCNumericType(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
     return error.ParseError;
 }
 
-fn parseCAbstractDeclarator(c: *Context, m: *MacroCtx, scope: *Scope, node: Node) ParseError!Node {
-    _ = scope;
+fn parseCAbstractDeclarator(c: *Context, m: *MacroCtx, node: Node) ParseError!Node {
     switch (m.next().?) {
         .Asterisk => {
             // last token of `node`

From 4fc944dde813638410850515b0d1b156e5b6e920 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 24 Oct 2022 15:17:01 +0300
Subject: [PATCH 32/70] translate-c: fix redefinition of label on left
 recursive comma operator

Closes #13239
---
 src/translate_c.zig                  | 7 ++++---
 test/behavior/translate_c_macros.h   | 1 +
 test/behavior/translate_c_macros.zig | 1 +
 test/translate_c.zig                 | 8 ++++----
 4 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/translate_c.zig b/src/translate_c.zig
index 219635859c..7cc843e17c 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -5651,13 +5651,14 @@ const ParseError = Error || error{ParseError};
 
 fn parseCExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
     // TODO parseCAssignExpr here
-    const node = try parseCCondExpr(c, m, scope);
+    var block_scope = try Scope.Block.init(c, scope, true);
+    defer block_scope.deinit();
+
+    const node = try parseCCondExpr(c, m, &block_scope.base);
     if (m.next().? != .Comma) {
         m.i -= 1;
         return node;
     }
-    var block_scope = try Scope.Block.init(c, scope, true);
-    defer block_scope.deinit();
 
     var last = node;
     while (true) {
diff --git a/test/behavior/translate_c_macros.h b/test/behavior/translate_c_macros.h
index 439577fecc..5d4cf3473d 100644
--- a/test/behavior/translate_c_macros.h
+++ b/test/behavior/translate_c_macros.h
@@ -40,6 +40,7 @@ union U {
 #define CAST_OR_CALL_WITH_PARENS(type_or_fn, val) ((type_or_fn)(val))
 
 #define NESTED_COMMA_OPERATOR (1, (2, 3))
+#define NESTED_COMMA_OPERATOR_LHS (1, 2), 3
 
 #include <stdint.h>
 #if !defined(__UINTPTR_MAX__)
diff --git a/test/behavior/translate_c_macros.zig b/test/behavior/translate_c_macros.zig
index 04d217f488..deda45df91 100644
--- a/test/behavior/translate_c_macros.zig
+++ b/test/behavior/translate_c_macros.zig
@@ -100,6 +100,7 @@ test "nested comma operator" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR);
+    try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR_LHS);
 }
 
 test "cast functions" {
diff --git a/test/translate_c.zig b/test/translate_c.zig
index d6b6bcbbba..81d1308c95 100644
--- a/test/translate_c.zig
+++ b/test/translate_c.zig
@@ -499,20 +499,20 @@ pub fn addCases(cases: *tests.TranslateCContext) void {
         \\int baz(int x, int y) { return 0; }
         \\#define bar(x) (&x, +3, 4 == 4, 5 * 6, baz(1, 2), 2 % 2, baz(1,2))
     , &[_][]const u8{
-        \\pub const foo = blk: {
+        \\pub const foo = blk_1: {
         \\    _ = @TypeOf(foo);
-        \\    break :blk bar;
+        \\    break :blk_1 bar;
         \\};
         ,
         \\pub inline fn bar(x: anytype) @TypeOf(baz(@as(c_int, 1), @as(c_int, 2))) {
-        \\    return blk: {
+        \\    return blk_1: {
         \\        _ = &x;
         \\        _ = @as(c_int, 3);
         \\        _ = @as(c_int, 4) == @as(c_int, 4);
         \\        _ = @as(c_int, 5) * @as(c_int, 6);
         \\        _ = baz(@as(c_int, 1), @as(c_int, 2));
         \\        _ = @as(c_int, 2) % @as(c_int, 2);
-        \\        break :blk baz(@as(c_int, 1), @as(c_int, 2));
+        \\        break :blk_1 baz(@as(c_int, 1), @as(c_int, 2));
         \\    };
         \\}
     });

From 4ac8ec4c5c80f6eca0ac7d7955c5486ef55ce042 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 24 Oct 2022 17:30:47 +0300
Subject: [PATCH 33/70] AstGen: fix `ref`ing inferred allocs

Closes  #13285
---
 src/AstGen.zig               |  9 ++++++++-
 test/behavior.zig            |  3 ++-
 test/behavior/bugs/13285.zig | 11 +++++++++++
 3 files changed, 21 insertions(+), 2 deletions(-)
 create mode 100644 test/behavior/bugs/13285.zig

diff --git a/src/AstGen.zig b/src/AstGen.zig
index 07a972eaab..48e6a480f3 100644
--- a/src/AstGen.zig
+++ b/src/AstGen.zig
@@ -9709,7 +9709,7 @@ fn rvalue(
             const result_index = refToIndex(result) orelse
                 return gz.addUnTok(.ref, result, src_token);
             const zir_tags = gz.astgen.instructions.items(.tag);
-            if (zir_tags[result_index].isParam())
+            if (zir_tags[result_index].isParam() or astgen.isInferred(result))
                 return gz.addUnTok(.ref, result, src_token);
             const gop = try astgen.ref_table.getOrPut(astgen.gpa, result_index);
             if (!gop.found_existing) {
@@ -12196,6 +12196,13 @@ fn isInferred(astgen: *AstGen, ref: Zir.Inst.Ref) bool {
         .alloc_inferred_comptime_mut,
         => true,
 
+        .extended => {
+            const zir_data = astgen.instructions.items(.data);
+            if (zir_data[inst].extended.opcode != .alloc) return false;
+            const small = @bitCast(Zir.Inst.AllocExtended.Small, zir_data[inst].extended.small);
+            return !small.has_type;
+        },
+
         else => false,
     };
 }
diff --git a/test/behavior.zig b/test/behavior.zig
index 442b27c09f..aa59fb32b0 100644
--- a/test/behavior.zig
+++ b/test/behavior.zig
@@ -108,8 +108,9 @@ test {
     _ = @import("behavior/bugs/13112.zig");
     _ = @import("behavior/bugs/13128.zig");
     _ = @import("behavior/bugs/13164.zig");
-    _ = @import("behavior/bugs/13171.zig");
     _ = @import("behavior/bugs/13159.zig");
+    _ = @import("behavior/bugs/13171.zig");
+    _ = @import("behavior/bugs/13285.zig");
     _ = @import("behavior/byteswap.zig");
     _ = @import("behavior/byval_arg_var.zig");
     _ = @import("behavior/call.zig");
diff --git a/test/behavior/bugs/13285.zig b/test/behavior/bugs/13285.zig
new file mode 100644
index 0000000000..ad37f9876a
--- /dev/null
+++ b/test/behavior/bugs/13285.zig
@@ -0,0 +1,11 @@
+const Crasher = struct {
+    lets_crash: u64 = 0,
+};
+
+test {
+    var a: Crasher = undefined;
+    var crasher_ptr = &a;
+    var crasher_local = crasher_ptr.*;
+    const crasher_local_ptr = &crasher_local;
+    crasher_local_ptr.lets_crash = 1;
+}

From 9dcfc829e650bc9c0a89e9f7778744c774120c09 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 24 Oct 2022 17:47:32 +0300
Subject: [PATCH 34/70] Sema: fix some edge cases with error return traces and
 typeof blocks

Closes #13293
---
 src/Sema.zig | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 4c2f72034e..9c52fd91a3 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -5031,6 +5031,7 @@ fn zirBlock(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileErro
         .label = &label,
         .inlining = parent_block.inlining,
         .is_comptime = parent_block.is_comptime,
+        .is_typeof = parent_block.is_typeof,
         .want_safety = parent_block.want_safety,
         .float_mode = parent_block.float_mode,
         .runtime_cond = parent_block.runtime_cond,
@@ -5923,7 +5924,7 @@ fn zirCall(
 
     const backend_supports_error_return_tracing = sema.mod.comp.bin_file.options.use_llvm;
     if (backend_supports_error_return_tracing and sema.mod.comp.bin_file.options.error_return_tracing and
-        !block.is_comptime and (input_is_error or pop_error_return_trace))
+        !block.is_comptime and !block.is_typeof and (input_is_error or pop_error_return_trace))
     {
         const call_inst: Air.Inst.Ref = if (modifier == .always_tail) undefined else b: {
             break :b try sema.analyzeCall(block, func, func_src, call_src, modifier, ensure_result_used, resolved_args, bound_arg_src);
@@ -6403,7 +6404,7 @@ fn analyzeCall(
             }
 
             const new_func_resolved_ty = try Type.Tag.function.create(sema.arena, new_fn_info);
-            if (!is_comptime_call) {
+            if (!is_comptime_call and !block.is_typeof) {
                 try sema.emitDbgInline(block, parent_func.?, module_fn, new_func_resolved_ty, .dbg_inline_begin);
 
                 const zir_tags = sema.code.instructions.items(.tag);
@@ -6441,7 +6442,7 @@ fn analyzeCall(
                 break :result try sema.analyzeBlockBody(block, call_src, &child_block, merges);
             };
 
-            if (!is_comptime_call and sema.typeOf(result).zigTypeTag() != .NoReturn) {
+            if (!is_comptime_call and !block.is_typeof and sema.typeOf(result).zigTypeTag() != .NoReturn) {
                 try sema.emitDbgInline(
                     block,
                     module_fn,
@@ -10210,6 +10211,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         .label = &label,
         .inlining = block.inlining,
         .is_comptime = block.is_comptime,
+        .is_typeof = block.is_typeof,
         .switch_else_err_ty = else_error_ty,
         .runtime_cond = block.runtime_cond,
         .runtime_loop = block.runtime_loop,
@@ -16401,7 +16403,7 @@ fn zirSaveErrRetIndex(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE
     if (!ok) return;
 
     // This is only relevant at runtime.
-    if (block.is_comptime) return;
+    if (block.is_comptime or block.is_typeof) return;
 
     // This is only relevant within functions.
     if (sema.func == null) return;
@@ -16421,7 +16423,7 @@ fn zirRestoreErrRetIndex(sema: *Sema, start_block: *Block, inst: Zir.Inst.Index)
     const src = sema.src; // TODO
 
     // This is only relevant at runtime.
-    if (start_block.is_comptime) return;
+    if (start_block.is_comptime or start_block.is_typeof) return;
 
     const backend_supports_error_return_tracing = sema.mod.comp.bin_file.options.use_llvm;
     const ok = sema.owner_func.?.calls_or_awaits_errorable_fn and

From d9fe5ba7f805c82f14c162945ac851ebb570ec89 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Mon, 24 Oct 2022 22:19:24 +0300
Subject: [PATCH 35/70] Sema: add error for too big packed struct

---
 src/Sema.zig                                  | 27 +++++++++++++++++++
 .../compile_errors/too_big_packed_struct.zig  | 13 +++++++++
 2 files changed, 40 insertions(+)
 create mode 100644 test/cases/compile_errors/too_big_packed_struct.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index 9c52fd91a3..d1a558d15b 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -29075,6 +29075,33 @@ fn semaBackingIntType(mod: *Module, struct_obj: *Module.Struct) CompileError!voi
         struct_obj.backing_int_ty = try backing_int_ty.copy(decl_arena_allocator);
         try wip_captures.finalize();
     } else {
+        if (fields_bit_sum > std.math.maxInt(u16)) {
+            var sema: Sema = .{
+                .mod = mod,
+                .gpa = gpa,
+                .arena = undefined,
+                .perm_arena = decl_arena_allocator,
+                .code = zir,
+                .owner_decl = decl,
+                .owner_decl_index = decl_index,
+                .func = null,
+                .fn_ret_ty = Type.void,
+                .owner_func = null,
+            };
+            defer sema.deinit();
+
+            var block: Block = .{
+                .parent = null,
+                .sema = &sema,
+                .src_decl = decl_index,
+                .namespace = &struct_obj.namespace,
+                .wip_capture_scope = undefined,
+                .instructions = .{},
+                .inlining = null,
+                .is_comptime = true,
+            };
+            return sema.fail(&block, LazySrcLoc.nodeOffset(0), "size of packed struct '{d}' exceeds maximum bit width of 65535", .{fields_bit_sum});
+        }
         var buf: Type.Payload.Bits = .{
             .base = .{ .tag = .int_unsigned },
             .data = @intCast(u16, fields_bit_sum),
diff --git a/test/cases/compile_errors/too_big_packed_struct.zig b/test/cases/compile_errors/too_big_packed_struct.zig
new file mode 100644
index 0000000000..bedc4a72a6
--- /dev/null
+++ b/test/cases/compile_errors/too_big_packed_struct.zig
@@ -0,0 +1,13 @@
+pub export fn entry() void {
+    const T = packed struct {
+        a: u65535,
+        b: u65535,
+    };
+    @compileLog(@sizeOf(T));
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:22: error: size of packed struct '131070' exceeds maximum bit width of 65535

From 5b79f42dc5220850b67ac461a326d5a6253da215 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Tue, 25 Oct 2022 16:09:51 +0300
Subject: [PATCH 36/70] std.mem.Allocator: do not return undefined pointers

---
 lib/std/mem/Allocator.zig | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/lib/std/mem/Allocator.zig b/lib/std/mem/Allocator.zig
index 5997a06b9f..a574f8f37d 100644
--- a/lib/std/mem/Allocator.zig
+++ b/lib/std/mem/Allocator.zig
@@ -286,7 +286,8 @@ pub fn allocAdvancedWithRetAddr(
     } else @alignOf(T);
 
     if (n == 0) {
-        return @as([*]align(a) T, undefined)[0..0];
+        const ptr = comptime std.mem.alignBackward(std.math.maxInt(usize), a);
+        return @intToPtr([*]align(a) T, ptr)[0..0];
     }
 
     const byte_count = math.mul(usize, @sizeOf(T), n) catch return Error.OutOfMemory;
@@ -383,7 +384,8 @@ pub fn reallocAdvancedWithRetAddr(
     }
     if (new_n == 0) {
         self.free(old_mem);
-        return @as([*]align(new_alignment) T, undefined)[0..0];
+        const ptr = comptime std.mem.alignBackward(std.math.maxInt(usize), new_alignment);
+        return @intToPtr([*]align(new_alignment) T, ptr)[0..0];
     }
 
     const old_byte_slice = mem.sliceAsBytes(old_mem);
@@ -462,7 +464,8 @@ pub fn alignedShrinkWithRetAddr(
         return old_mem;
     if (new_n == 0) {
         self.free(old_mem);
-        return @as([*]align(new_alignment) T, undefined)[0..0];
+        const ptr = comptime std.mem.alignBackward(std.math.maxInt(usize), new_alignment);
+        return @intToPtr([*]align(new_alignment) T, ptr)[0..0];
     }
 
     assert(new_n < old_mem.len);

From 595ccecd88d82874e7f677ee1809c04fc29424ff Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Tue, 25 Oct 2022 16:10:09 +0300
Subject: [PATCH 37/70] llvm: do not return undefined pointers from
 array_to_slice

---
 src/codegen/llvm.zig | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 18b89eef78..2eb95dc5e3 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -5434,10 +5434,11 @@ pub const FuncGen = struct {
         const llvm_usize = try self.dg.lowerType(Type.usize);
         const len = llvm_usize.constInt(array_ty.arrayLen(), .False);
         const slice_llvm_ty = try self.dg.lowerType(self.air.typeOfIndex(inst));
-        if (!array_ty.hasRuntimeBitsIgnoreComptime()) {
-            return self.builder.buildInsertValue(slice_llvm_ty.getUndef(), len, 1, "");
-        }
         const operand = try self.resolveInst(ty_op.operand);
+        if (!array_ty.hasRuntimeBitsIgnoreComptime()) {
+            const partial = self.builder.buildInsertValue(slice_llvm_ty.getUndef(), operand, 0, "");
+            return self.builder.buildInsertValue(partial, len, 1, "");
+        }
         const indices: [2]*llvm.Value = .{
             llvm_usize.constNull(), llvm_usize.constNull(),
         };

From f3a3fb3d880528e8b6404648c605ed092ef1412c Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Thu, 27 Oct 2022 00:23:43 +0300
Subject: [PATCH 38/70] llvm: pass optional slices like regular slices

---
 src/codegen/llvm.zig | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index 2eb95dc5e3..2660b19bf3 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -1027,7 +1027,9 @@ pub const Object = struct {
                             dg.addArgAttr(llvm_func, llvm_arg_i, "noalias");
                         }
                     }
-                    dg.addArgAttr(llvm_func, llvm_arg_i, "nonnull");
+                    if (param_ty.zigTypeTag() != .Optional) {
+                        dg.addArgAttr(llvm_func, llvm_arg_i, "nonnull");
+                    }
                     if (!ptr_info.mutable) {
                         dg.addArgAttr(llvm_func, llvm_arg_i, "readonly");
                     }
@@ -3117,7 +3119,11 @@ pub const DeclGen = struct {
             .slice => {
                 const param_ty = fn_info.param_types[it.zig_index - 1];
                 var buf: Type.SlicePtrFieldTypeBuffer = undefined;
-                const ptr_ty = param_ty.slicePtrFieldType(&buf);
+                var opt_buf: Type.Payload.ElemType = undefined;
+                const ptr_ty = if (param_ty.zigTypeTag() == .Optional)
+                    param_ty.optionalChild(&opt_buf).slicePtrFieldType(&buf)
+                else
+                    param_ty.slicePtrFieldType(&buf);
                 const ptr_llvm_ty = try dg.lowerType(ptr_ty);
                 const len_llvm_ty = try dg.lowerType(Type.usize);
 
@@ -10358,7 +10364,8 @@ const ParamTypeIterator = struct {
             .Unspecified, .Inline => {
                 it.zig_index += 1;
                 it.llvm_index += 1;
-                if (ty.isSlice()) {
+                var buf: Type.Payload.ElemType = undefined;
+                if (ty.isSlice() or (ty.zigTypeTag() == .Optional and ty.optionalChild(&buf).isSlice())) {
                     return .slice;
                 } else if (isByRef(ty)) {
                     return .byref;

From b937a045607deae158ccb6a00f5defaf36510e61 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Thu, 27 Oct 2022 00:48:56 +0300
Subject: [PATCH 39/70] Sema: check `coerceInMemoryAllowed` earlier in
 `resolvePeerTypes`

Closes #13310
---
 src/Sema.zig           | 21 +++++++++------------
 test/behavior/cast.zig |  7 +++++++
 2 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index d1a558d15b..b41dd21b81 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -28340,8 +28340,16 @@ fn resolvePeerTypes(
         const candidate_ty_tag = try candidate_ty.zigTypeTagOrPoison();
         const chosen_ty_tag = try chosen_ty.zigTypeTagOrPoison();
 
-        if (candidate_ty.eql(chosen_ty, sema.mod))
+        // If the candidate can coerce into our chosen type, we're done.
+        // If the chosen type can coerce into the candidate, use that.
+        if ((try sema.coerceInMemoryAllowed(block, chosen_ty, candidate_ty, false, target, src, src)) == .ok) {
             continue;
+        }
+        if ((try sema.coerceInMemoryAllowed(block, candidate_ty, chosen_ty, false, target, src, src)) == .ok) {
+            chosen = candidate;
+            chosen_i = candidate_i + 1;
+            continue;
+        }
 
         switch (candidate_ty_tag) {
             .NoReturn, .Undefined => continue,
@@ -28741,17 +28749,6 @@ fn resolvePeerTypes(
             else => {},
         }
 
-        // If the candidate can coerce into our chosen type, we're done.
-        // If the chosen type can coerce into the candidate, use that.
-        if ((try sema.coerceInMemoryAllowed(block, chosen_ty, candidate_ty, false, target, src, src)) == .ok) {
-            continue;
-        }
-        if ((try sema.coerceInMemoryAllowed(block, candidate_ty, chosen_ty, false, target, src, src)) == .ok) {
-            chosen = candidate;
-            chosen_i = candidate_i + 1;
-            continue;
-        }
-
         // At this point, we hit a compile error. We need to recover
         // the source locations.
         const chosen_src = candidate_srcs.resolve(
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index cb76f86820..8473abc3ef 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -1444,3 +1444,10 @@ test "coerce between pointers of compatible differently-named floats" {
     f2.* += 1;
     try expect(f1 == @as(F, 12.34) + 1);
 }
+
+test "peer type resolution of const and non-const pointer to array" {
+    const a = @intToPtr(*[1024]u8, 42);
+    const b = @intToPtr(*const [1024]u8, 42);
+    try std.testing.expect(@TypeOf(a, b) == *const [1024]u8);
+    try std.testing.expect(a == b);
+}

From 7d0dc2fd75fd0e62cb842e00e82633a35509f12b Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 26 Oct 2022 16:48:29 -0700
Subject: [PATCH 40/70] docgen: fix not escaping html in shell samples

---
 doc/docgen.zig | 60 ++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 43 insertions(+), 17 deletions(-)

diff --git a/doc/docgen.zig b/doc/docgen.zig
index 1f332e1ee0..3ba9a1442c 100644
--- a/doc/docgen.zig
+++ b/doc/docgen.zig
@@ -1168,7 +1168,7 @@ fn printSourceBlock(allocator: Allocator, docgen_tokenizer: *Tokenizer, out: any
     try out.writeAll("</pre></figure>");
 }
 
-fn printShell(out: anytype, shell_content: []const u8) !void {
+fn printShell(out: anytype, shell_content: []const u8, escape: bool) !void {
     const trimmed_shell_content = mem.trim(u8, shell_content, " \n");
     try out.writeAll("<figure><figcaption class=\"shell-cap\">Shell</figcaption><pre><samp>");
     var cmd_cont: bool = false;
@@ -1176,15 +1176,41 @@ fn printShell(out: anytype, shell_content: []const u8) !void {
     while (iter.next()) |orig_line| {
         const line = mem.trimRight(u8, orig_line, " ");
         if (!cmd_cont and line.len > 1 and mem.eql(u8, line[0..2], "$ ") and line[line.len - 1] != '\\') {
-            try out.print(start_line ++ "$ <kbd>{s}</kbd>" ++ end_line ++ "\n", .{std.mem.trimLeft(u8, line[1..], " ")});
+            try out.writeAll(start_line ++ "$ <kbd>");
+            const s = std.mem.trimLeft(u8, line[1..], " ");
+            if (escape) {
+                try writeEscaped(out, s);
+            } else {
+                try out.writeAll(s);
+            }
+            try out.writeAll("</kbd>" ++ end_line ++ "\n");
         } else if (!cmd_cont and line.len > 1 and mem.eql(u8, line[0..2], "$ ") and line[line.len - 1] == '\\') {
-            try out.print(start_line ++ "$ <kbd>{s}" ++ end_line ++ "\n", .{std.mem.trimLeft(u8, line[1..], " ")});
+            try out.writeAll(start_line ++ "$ <kbd>");
+            const s = std.mem.trimLeft(u8, line[1..], " ");
+            if (escape) {
+                try writeEscaped(out, s);
+            } else {
+                try out.writeAll(s);
+            }
+            try out.writeAll(end_line ++ "\n");
             cmd_cont = true;
         } else if (line.len > 0 and line[line.len - 1] != '\\' and cmd_cont) {
-            try out.print(start_line ++ "{s}</kbd>" ++ end_line ++ "\n", .{line});
+            try out.writeAll(start_line);
+            if (escape) {
+                try writeEscaped(out, line);
+            } else {
+                try out.writeAll(line);
+            }
+            try out.writeAll("</kbd>" ++ end_line ++ "\n");
             cmd_cont = false;
         } else {
-            try out.print(start_line ++ "{s}" ++ end_line ++ "\n", .{line});
+            try out.writeAll(start_line);
+            if (escape) {
+                try writeEscaped(out, line);
+            } else {
+                try out.writeAll(line);
+            }
+            try out.writeAll(end_line ++ "\n");
         }
     }
 
@@ -1254,7 +1280,7 @@ fn genHtml(
             },
             .Shell => |content_tok| {
                 const raw_shell_content = tokenizer.buffer[content_tok.start..content_tok.end];
-                try printShell(out, raw_shell_content);
+                try printShell(out, raw_shell_content, true);
             },
             .SyntaxBlock => |syntax_block| {
                 try printSourceBlock(allocator, tokenizer, out, syntax_block);
@@ -1730,7 +1756,7 @@ fn genHtml(
                 }
 
                 if (!code.just_check_syntax) {
-                    try printShell(out, shell_buffer.items);
+                    try printShell(out, shell_buffer.items, false);
                 }
             },
         }
@@ -1788,7 +1814,7 @@ test "shell parsed" {
         var buffer = std.ArrayList(u8).init(test_allocator);
         defer buffer.deinit();
 
-        try printShell(buffer.writer(), shell_out);
+        try printShell(buffer.writer(), shell_out, false);
         std.log.emerg("{s}", .{buffer.items});
         try testing.expectEqualSlices(u8, expected, buffer.items);
     }
@@ -1806,7 +1832,7 @@ test "shell parsed" {
         var buffer = std.ArrayList(u8).init(test_allocator);
         defer buffer.deinit();
 
-        try printShell(buffer.writer(), shell_out);
+        try printShell(buffer.writer(), shell_out, false);
         try testing.expectEqualSlices(u8, expected, buffer.items);
     }
     {
@@ -1825,7 +1851,7 @@ test "shell parsed" {
         var buffer = std.ArrayList(u8).init(test_allocator);
         defer buffer.deinit();
 
-        try printShell(buffer.writer(), shell_out);
+        try printShell(buffer.writer(), shell_out, false);
         try testing.expectEqualSlices(u8, expected, buffer.items);
     }
     {
@@ -1846,7 +1872,7 @@ test "shell parsed" {
         var buffer = std.ArrayList(u8).init(test_allocator);
         defer buffer.deinit();
 
-        try printShell(buffer.writer(), shell_out);
+        try printShell(buffer.writer(), shell_out, false);
         try testing.expectEqualSlices(u8, expected, buffer.items);
     }
     {
@@ -1865,7 +1891,7 @@ test "shell parsed" {
         var buffer = std.ArrayList(u8).init(test_allocator);
         defer buffer.deinit();
 
-        try printShell(buffer.writer(), shell_out);
+        try printShell(buffer.writer(), shell_out, false);
         try testing.expectEqualSlices(u8, expected, buffer.items);
     }
     {
@@ -1888,7 +1914,7 @@ test "shell parsed" {
         var buffer = std.ArrayList(u8).init(test_allocator);
         defer buffer.deinit();
 
-        try printShell(buffer.writer(), shell_out);
+        try printShell(buffer.writer(), shell_out, false);
         try testing.expectEqualSlices(u8, expected, buffer.items);
     }
     {
@@ -1910,7 +1936,7 @@ test "shell parsed" {
         var buffer = std.ArrayList(u8).init(test_allocator);
         defer buffer.deinit();
 
-        try printShell(buffer.writer(), shell_out);
+        try printShell(buffer.writer(), shell_out, false);
         try testing.expectEqualSlices(u8, expected, buffer.items);
     }
     {
@@ -1927,7 +1953,7 @@ test "shell parsed" {
         var buffer = std.ArrayList(u8).init(test_allocator);
         defer buffer.deinit();
 
-        try printShell(buffer.writer(), shell_out);
+        try printShell(buffer.writer(), shell_out, false);
         try testing.expectEqualSlices(u8, expected, buffer.items);
     }
     {
@@ -1946,7 +1972,7 @@ test "shell parsed" {
         var buffer = std.ArrayList(u8).init(test_allocator);
         defer buffer.deinit();
 
-        try printShell(buffer.writer(), shell_out);
+        try printShell(buffer.writer(), shell_out, false);
         try testing.expectEqualSlices(u8, expected, buffer.items);
     }
     {
@@ -1961,7 +1987,7 @@ test "shell parsed" {
         var buffer = std.ArrayList(u8).init(test_allocator);
         defer buffer.deinit();
 
-        try printShell(buffer.writer(), shell_out);
+        try printShell(buffer.writer(), shell_out, false);
         try testing.expectEqualSlices(u8, expected, buffer.items);
     }
 }

From 0b72965dbf545aa64eb9d9e33defc36af4e2e42c Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 26 Oct 2022 18:17:49 -0700
Subject: [PATCH 41/70] build: update Tracy integration

 * Update for v0.9
 * Enable the memory and callstack integrations by default
---
 build.zig | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/build.zig b/build.zig
index 538549ea91..e439b9cb33 100644
--- a/build.zig
+++ b/build.zig
@@ -122,8 +122,8 @@ pub fn build(b: *Builder) !void {
         return;
 
     const tracy = b.option([]const u8, "tracy", "Enable Tracy integration. Supply path to Tracy source");
-    const tracy_callstack = b.option(bool, "tracy-callstack", "Include callstack information with Tracy data. Does nothing if -Dtracy is not provided") orelse false;
-    const tracy_allocation = b.option(bool, "tracy-allocation", "Include allocation information with Tracy data. Does nothing if -Dtracy is not provided") orelse false;
+    const tracy_callstack = b.option(bool, "tracy-callstack", "Include callstack information with Tracy data. Does nothing if -Dtracy is not provided") orelse (tracy != null);
+    const tracy_allocation = b.option(bool, "tracy-allocation", "Include allocation information with Tracy data. Does nothing if -Dtracy is not provided") orelse (tracy != null);
     const force_gpa = b.option(bool, "force-gpa", "Force the compiler to use GeneralPurposeAllocator") orelse false;
     const link_libc = b.option(bool, "force-link-libc", "Force self-hosted compiler to link libc") orelse (enable_llvm or only_c);
     const sanitize_thread = b.option(bool, "sanitize-thread", "Enable thread-sanitization") orelse false;
@@ -378,7 +378,7 @@ pub fn build(b: *Builder) !void {
     if (tracy) |tracy_path| {
         const client_cpp = fs.path.join(
             b.allocator,
-            &[_][]const u8{ tracy_path, "TracyClient.cpp" },
+            &[_][]const u8{ tracy_path, "public", "TracyClient.cpp" },
         ) catch unreachable;
 
         // On mingw, we need to opt into windows 7+ to get some features required by tracy.
@@ -674,13 +674,12 @@ fn addCxxKnownPath(
     exe.addObjectFile(path_unpadded);
 
     // TODO a way to integrate with system c++ include files here
-    // cc -E -Wp,-v -xc++ /dev/null
+    // c++ -E -Wp,-v -xc++ /dev/null
     if (need_cpp_includes) {
         // I used these temporarily for testing something but we obviously need a
         // more general purpose solution here.
-        //exe.addIncludePath("/nix/store/fvf3qjqa5qpcjjkq37pb6ypnk1mzhf5h-gcc-9.3.0/lib/gcc/x86_64-unknown-linux-gnu/9.3.0/../../../../include/c++/9.3.0");
-        //exe.addIncludePath("/nix/store/fvf3qjqa5qpcjjkq37pb6ypnk1mzhf5h-gcc-9.3.0/lib/gcc/x86_64-unknown-linux-gnu/9.3.0/../../../../include/c++/9.3.0/x86_64-unknown-linux-gnu");
-        //exe.addIncludePath("/nix/store/fvf3qjqa5qpcjjkq37pb6ypnk1mzhf5h-gcc-9.3.0/lib/gcc/x86_64-unknown-linux-gnu/9.3.0/../../../../include/c++/9.3.0/backward");
+        //exe.addIncludePath("/nix/store/2lr0fc0ak8rwj0k8n3shcyz1hz63wzma-gcc-11.3.0/include/c++/11.3.0");
+        //exe.addIncludePath("/nix/store/2lr0fc0ak8rwj0k8n3shcyz1hz63wzma-gcc-11.3.0/include/c++/11.3.0/x86_64-unknown-linux-gnu");
     }
 }
 

From 710e2e7f1048cb7d5a7c8d2bdd954f108dd94e7a Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Wed, 26 Oct 2022 12:56:29 -0700
Subject: [PATCH 42/70] libcxx: only pass -DHAVE___CXA_THREAD_ATEXIT_IMPL for
 glibc

This definition communicates to libcxxabi that the libc will provide the
`__cxa_thread_atexit_impl` symbol. This is true for glibc but not
true for other libcs, such as musl.
---
 src/libcxx.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libcxx.zig b/src/libcxx.zig
index b0261aaed6..850da698c5 100644
--- a/src/libcxx.zig
+++ b/src/libcxx.zig
@@ -320,7 +320,7 @@ pub fn buildLibCXXABI(comp: *Compilation) !void {
             }
             try cflags.append("-D_LIBCXXABI_HAS_NO_THREADS");
             try cflags.append("-D_LIBCPP_HAS_NO_THREADS");
-        } else {
+        } else if (target.abi.isGnu()) {
             try cflags.append("-DHAVE___CXA_THREAD_ATEXIT_IMPL");
         }
 

From 648d34d8eacaf2e35e336abd5b0c50c2ab9bfc94 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Thu, 27 Oct 2022 13:40:20 +0300
Subject: [PATCH 43/70] Sema: coerce zero-bit generic args are coerced properly

Closes #13307
---
 src/Sema.zig                                           |  2 ++
 ...zero-bit_generic_args_are_coerced_to_param_type.zig | 10 ++++++++++
 2 files changed, 12 insertions(+)
 create mode 100644 test/cases/compile_errors/zero-bit_generic_args_are_coerced_to_param_type.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index b41dd21b81..43c8b88372 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -6738,6 +6738,8 @@ fn analyzeGenericCallArg(
         try sema.queueFullTypeResolution(param_ty);
         runtime_args[runtime_i.*] = casted_arg;
         runtime_i.* += 1;
+    } else if (try sema.typeHasOnePossibleValue(block, arg_src, comptime_arg.ty)) |_| {
+        _ = try sema.coerce(block, comptime_arg.ty, uncasted_arg, arg_src);
     }
 }
 
diff --git a/test/cases/compile_errors/zero-bit_generic_args_are_coerced_to_param_type.zig b/test/cases/compile_errors/zero-bit_generic_args_are_coerced_to_param_type.zig
new file mode 100644
index 0000000000..0288979084
--- /dev/null
+++ b/test/cases/compile_errors/zero-bit_generic_args_are_coerced_to_param_type.zig
@@ -0,0 +1,10 @@
+fn bar(a: anytype, _: @TypeOf(a)) void {}
+pub export fn entry() void {
+    bar(@as(u0, 0), "fooo");
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:21: error: expected type 'u0', found '*const [4:0]u8'

From 9c0d975a099387cd2b47e527892e71ae1601eaf4 Mon Sep 17 00:00:00 2001
From: Frank Denis <124872+jedisct1@users.noreply.github.com>
Date: Thu, 27 Oct 2022 19:07:42 +0200
Subject: [PATCH 44/70] Revamp the ed25519 API (#13309)

---
 lib/std/crypto/25519/ed25519.zig | 574 +++++++++++++++++++++----------
 lib/std/crypto/25519/x25519.zig  |   8 +-
 lib/std/crypto/benchmark.zig     |  22 +-
 3 files changed, 403 insertions(+), 201 deletions(-)

diff --git a/lib/std/crypto/25519/ed25519.zig b/lib/std/crypto/25519/ed25519.zig
index 7066b1a154..0a9db10d15 100644
--- a/lib/std/crypto/25519/ed25519.zig
+++ b/lib/std/crypto/25519/ed25519.zig
@@ -16,27 +16,227 @@ const WeakPublicKeyError = crypto.errors.WeakPublicKeyError;
 /// Ed25519 (EdDSA) signatures.
 pub const Ed25519 = struct {
     /// The underlying elliptic curve.
-    pub const Curve = @import("edwards25519.zig").Edwards25519;
-    /// Length (in bytes) of a seed required to create a key pair.
-    pub const seed_length = 32;
-    /// Length (in bytes) of a compressed secret key.
-    pub const secret_length = 64;
-    /// Length (in bytes) of a compressed public key.
-    pub const public_length = 32;
-    /// Length (in bytes) of a signature.
-    pub const signature_length = 64;
+    pub const Curve = std.crypto.ecc.Edwards25519;
+
     /// Length (in bytes) of optional random bytes, for non-deterministic signatures.
     pub const noise_length = 32;
 
     const CompressedScalar = Curve.scalar.CompressedScalar;
     const Scalar = Curve.scalar.Scalar;
 
+    /// An Ed25519 secret key.
+    pub const SecretKey = struct {
+        /// Length (in bytes) of a raw secret key.
+        pub const encoded_length = 64;
+
+        bytes: [encoded_length]u8,
+
+        /// Return the seed used to generate this secret key.
+        pub fn seed(self: SecretKey) [KeyPair.seed_length]u8 {
+            return self.bytes[0..KeyPair.seed_length].*;
+        }
+
+        /// Return the raw public key bytes corresponding to this secret key.
+        pub fn publicKeyBytes(self: SecretKey) [PublicKey.encoded_length]u8 {
+            return self.bytes[KeyPair.seed_length..].*;
+        }
+
+        /// Create a secret key from raw bytes.
+        pub fn fromBytes(bytes: [encoded_length]u8) !SecretKey {
+            return SecretKey{ .bytes = bytes };
+        }
+
+        /// Return the secret key as raw bytes.
+        pub fn toBytes(sk: SecretKey) [encoded_length]u8 {
+            return sk.bytes;
+        }
+
+        // Return the clamped secret scalar and prefix for this secret key
+        fn scalarAndPrefix(self: SecretKey) struct { scalar: CompressedScalar, prefix: [32]u8 } {
+            var az: [Sha512.digest_length]u8 = undefined;
+            var h = Sha512.init(.{});
+            h.update(&self.seed());
+            h.final(&az);
+
+            var s = az[0..32].*;
+            Curve.scalar.clamp(&s);
+
+            return .{ .scalar = s, .prefix = az[32..].* };
+        }
+    };
+
+    /// A Signer is used to incrementally compute a signature.
+    /// It can be obtained from a `KeyPair`, using the `signer()` function.
+    pub const Signer = struct {
+        h: Sha512,
+        scalar: CompressedScalar,
+        nonce: CompressedScalar,
+        r_bytes: [Curve.encoded_length]u8,
+
+        fn init(scalar: CompressedScalar, nonce: CompressedScalar, public_key: PublicKey) (IdentityElementError || KeyMismatchError || NonCanonicalError || WeakPublicKeyError)!Signer {
+            const r = try Curve.basePoint.mul(nonce);
+            const r_bytes = r.toBytes();
+
+            var t: [64]u8 = undefined;
+            mem.copy(u8, t[0..32], &r_bytes);
+            mem.copy(u8, t[32..], &public_key.bytes);
+            var h = Sha512.init(.{});
+            h.update(&t);
+
+            return Signer{ .h = h, .scalar = scalar, .nonce = nonce, .r_bytes = r_bytes };
+        }
+
+        /// Add new data to the message being signed.
+        pub fn update(self: *Signer, data: []const u8) void {
+            self.h.update(data);
+        }
+
+        /// Compute a signature over the entire message.
+        pub fn finalize(self: *Signer) Signature {
+            var hram64: [Sha512.digest_length]u8 = undefined;
+            self.h.final(&hram64);
+            const hram = Curve.scalar.reduce64(hram64);
+
+            const s = Curve.scalar.mulAdd(hram, self.scalar, self.nonce);
+
+            return Signature{ .r = self.r_bytes, .s = s };
+        }
+    };
+
+    /// An Ed25519 public key.
+    pub const PublicKey = struct {
+        /// Length (in bytes) of a raw public key.
+        pub const encoded_length = 32;
+
+        bytes: [encoded_length]u8,
+
+        /// Create a public key from raw bytes.
+        pub fn fromBytes(bytes: [encoded_length]u8) NonCanonicalError!PublicKey {
+            try Curve.rejectNonCanonical(bytes);
+            return PublicKey{ .bytes = bytes };
+        }
+
+        /// Convert a public key to raw bytes.
+        pub fn toBytes(pk: PublicKey) [encoded_length]u8 {
+            return pk.bytes;
+        }
+
+        fn signWithNonce(public_key: PublicKey, msg: []const u8, scalar: CompressedScalar, nonce: CompressedScalar) (IdentityElementError || NonCanonicalError || KeyMismatchError || WeakPublicKeyError)!Signature {
+            var st = try Signer.init(scalar, nonce, public_key);
+            st.update(msg);
+            return st.finalize();
+        }
+
+        fn computeNonceAndSign(public_key: PublicKey, msg: []const u8, noise: ?[noise_length]u8, scalar: CompressedScalar, prefix: []const u8) (IdentityElementError || NonCanonicalError || KeyMismatchError || WeakPublicKeyError)!Signature {
+            var h = Sha512.init(.{});
+            if (noise) |*z| {
+                h.update(z);
+            }
+            h.update(prefix);
+            h.update(msg);
+            var nonce64: [64]u8 = undefined;
+            h.final(&nonce64);
+
+            const nonce = Curve.scalar.reduce64(nonce64);
+
+            return public_key.signWithNonce(msg, scalar, nonce);
+        }
+    };
+
+    /// A Verifier is used to incrementally verify a signature.
+    /// It can be obtained from a `Signature`, using the `verifier()` function.
+    pub const Verifier = struct {
+        h: Sha512,
+        s: CompressedScalar,
+        a: Curve,
+        expected_r: Curve,
+
+        fn init(sig: Signature, public_key: PublicKey) (NonCanonicalError || EncodingError || IdentityElementError)!Verifier {
+            const r = sig.r;
+            const s = sig.s;
+            try Curve.scalar.rejectNonCanonical(s);
+            const a = try Curve.fromBytes(public_key.bytes);
+            try a.rejectIdentity();
+            try Curve.rejectNonCanonical(r);
+            const expected_r = try Curve.fromBytes(r);
+            try expected_r.rejectIdentity();
+
+            var h = Sha512.init(.{});
+            h.update(&r);
+            h.update(&public_key.bytes);
+
+            return Verifier{ .h = h, .s = s, .a = a, .expected_r = expected_r };
+        }
+
+        /// Add new content to the message to be verified.
+        pub fn update(self: *Verifier, msg: []const u8) void {
+            self.h.update(msg);
+        }
+
+        /// Verify that the signature is valid for the entire message.
+        pub fn verify(self: *Verifier) (SignatureVerificationError || WeakPublicKeyError || IdentityElementError)!void {
+            var hram64: [Sha512.digest_length]u8 = undefined;
+            self.h.final(&hram64);
+            const hram = Curve.scalar.reduce64(hram64);
+
+            const sb_ah = try Curve.basePoint.mulDoubleBasePublic(self.s, self.a.neg(), hram);
+            if (self.expected_r.sub(sb_ah).clearCofactor().rejectIdentity()) |_| {
+                return error.SignatureVerificationFailed;
+            } else |_| {}
+        }
+    };
+
+    /// An Ed25519 signature.
+    pub const Signature = struct {
+        /// Length (in bytes) of a raw signature.
+        pub const encoded_length = Curve.encoded_length + @sizeOf(CompressedScalar);
+
+        /// The R component of an EdDSA signature.
+        r: [Curve.encoded_length]u8,
+        /// The S component of an EdDSA signature.
+        s: CompressedScalar,
+
+        /// Return the raw signature (r, s) in little-endian format.
+        pub fn toBytes(self: Signature) [encoded_length]u8 {
+            var bytes: [encoded_length]u8 = undefined;
+            mem.copy(u8, bytes[0 .. encoded_length / 2], &self.r);
+            mem.copy(u8, bytes[encoded_length / 2 ..], &self.s);
+            return bytes;
+        }
+
+        /// Create a signature from a raw encoding of (r, s).
+        /// EdDSA always assumes little-endian.
+        pub fn fromBytes(bytes: [encoded_length]u8) Signature {
+            return Signature{
+                .r = bytes[0 .. encoded_length / 2].*,
+                .s = bytes[encoded_length / 2 ..].*,
+            };
+        }
+
+        /// Create a Verifier for incremental verification of a signature.
+        pub fn verifier(self: Signature, public_key: PublicKey) (NonCanonicalError || EncodingError || IdentityElementError)!Verifier {
+            return Verifier.init(self, public_key);
+        }
+
+        /// Verify the signature against a message and public key.
+        /// Return IdentityElement or NonCanonical if the public key or signature are not in the expected range,
+        /// or SignatureVerificationError if the signature is invalid for the given message and key.
+        pub fn verify(self: Signature, msg: []const u8, public_key: PublicKey) (IdentityElementError || NonCanonicalError || SignatureVerificationError || EncodingError || WeakPublicKeyError)!void {
+            var st = try Verifier.init(self, public_key);
+            st.update(msg);
+            return st.verify();
+        }
+    };
+
     /// An Ed25519 key pair.
     pub const KeyPair = struct {
+        /// Length (in bytes) of a seed required to create a key pair.
+        pub const seed_length = noise_length;
+
         /// Public part.
-        public_key: [public_length]u8,
-        /// Secret part. What we expose as a secret key is, under the hood, the concatenation of the seed and the public key.
-        secret_key: [secret_length]u8,
+        public_key: PublicKey,
+        /// Secret scalar.
+        secret_key: SecretKey,
 
         /// Derive a key pair from an optional secret seed.
         ///
@@ -56,120 +256,101 @@ pub const Ed25519 = struct {
             var h = Sha512.init(.{});
             h.update(&ss);
             h.final(&az);
-            const p = Curve.basePoint.clampedMul(az[0..32].*) catch return error.IdentityElement;
-            var sk: [secret_length]u8 = undefined;
-            mem.copy(u8, &sk, &ss);
-            const pk = p.toBytes();
-            mem.copy(u8, sk[seed_length..], &pk);
-
-            return KeyPair{ .public_key = pk, .secret_key = sk };
+            const pk_p = Curve.basePoint.clampedMul(az[0..32].*) catch return error.IdentityElement;
+            const pk_bytes = pk_p.toBytes();
+            var sk_bytes: [SecretKey.encoded_length]u8 = undefined;
+            mem.copy(u8, &sk_bytes, &ss);
+            mem.copy(u8, sk_bytes[seed_length..], &pk_bytes);
+            return KeyPair{
+                .public_key = PublicKey.fromBytes(pk_bytes) catch unreachable,
+                .secret_key = try SecretKey.fromBytes(sk_bytes),
+            };
         }
 
         /// Create a KeyPair from a secret key.
-        pub fn fromSecretKey(secret_key: [secret_length]u8) KeyPair {
+        pub fn fromSecretKey(secret_key: SecretKey) IdentityElementError!KeyPair {
+            const pk_p = try Curve.fromBytes(secret_key.publicKeyBytes());
+
+            // It is critical for EdDSA to use the correct public key.
+            // In order to enforce this, a SecretKey implicitly includes a copy of the public key.
+            // In Debug mode, we can still afford checking that the public key is correct for extra safety.
+            if (std.builtin.mode == .Debug) {
+                const recomputed_kp = try create(secret_key[0..seed_length].*);
+                debug.assert(recomputed_kp.public_key.p.toBytes() == pk_p.toBytes());
+            }
             return KeyPair{
+                .public_key = PublicKey{ .p = pk_p },
                 .secret_key = secret_key,
-                .public_key = secret_key[seed_length..].*,
             };
         }
+
+        /// Sign a message using the key pair.
+        /// The noise can be null in order to create deterministic signatures.
+        /// If deterministic signatures are not required, the noise should be randomly generated instead.
+        /// This helps defend against fault attacks.
+        pub fn sign(key_pair: KeyPair, msg: []const u8, noise: ?[noise_length]u8) (IdentityElementError || NonCanonicalError || KeyMismatchError || WeakPublicKeyError)!Signature {
+            if (!mem.eql(u8, &key_pair.secret_key.publicKeyBytes(), &key_pair.public_key.toBytes())) {
+                return error.KeyMismatch;
+            }
+            const scalar_and_prefix = key_pair.secret_key.scalarAndPrefix();
+            return key_pair.public_key.computeNonceAndSign(
+                msg,
+                noise,
+                scalar_and_prefix.scalar,
+                &scalar_and_prefix.prefix,
+            );
+        }
+
+        /// Create a Signer, that can be used for incremental signing.
+        /// Note that the signature is not deterministic.
+        /// The noise parameter, if set, should be something unique for each message,
+        /// such as a random nonce, or a counter.
+        pub fn signer(key_pair: KeyPair, noise: ?[noise_length]u8) (IdentityElementError || KeyMismatchError || NonCanonicalError || WeakPublicKeyError)!Signer {
+            if (!mem.eql(u8, &key_pair.secret_key.publicKeyBytes(), &key_pair.public_key.toBytes())) {
+                return error.KeyMismatch;
+            }
+            const scalar_and_prefix = key_pair.secret_key.scalarAndPrefix();
+            var h = Sha512.init(.{});
+            h.update(&scalar_and_prefix.prefix);
+            var noise2: [noise_length]u8 = undefined;
+            crypto.random.bytes(&noise2);
+            if (noise) |*z| {
+                h.update(z);
+            }
+            var nonce64: [64]u8 = undefined;
+            h.final(&nonce64);
+            const nonce = Curve.scalar.reduce64(nonce64);
+
+            return Signer.init(scalar_and_prefix.scalar, nonce, key_pair.public_key);
+        }
     };
 
-    /// Sign a message using a key pair, and optional random noise.
-    /// Having noise creates non-standard, non-deterministic signatures,
-    /// but has been proven to increase resilience against fault attacks.
-    pub fn sign(msg: []const u8, key_pair: KeyPair, noise: ?[noise_length]u8) (IdentityElementError || WeakPublicKeyError || KeyMismatchError)![signature_length]u8 {
-        const seed = key_pair.secret_key[0..seed_length];
-        const public_key = key_pair.secret_key[seed_length..];
-        if (!mem.eql(u8, public_key, &key_pair.public_key)) {
-            return error.KeyMismatch;
-        }
-        var az: [Sha512.digest_length]u8 = undefined;
-        var h = Sha512.init(.{});
-        h.update(seed);
-        h.final(&az);
-
-        h = Sha512.init(.{});
-        if (noise) |*z| {
-            h.update(z);
-        }
-        h.update(az[32..]);
-        h.update(msg);
-        var nonce64: [64]u8 = undefined;
-        h.final(&nonce64);
-        const nonce = Curve.scalar.reduce64(nonce64);
-        const r = try Curve.basePoint.mul(nonce);
-
-        var sig: [signature_length]u8 = undefined;
-        mem.copy(u8, sig[0..32], &r.toBytes());
-        mem.copy(u8, sig[32..], public_key);
-        h = Sha512.init(.{});
-        h.update(&sig);
-        h.update(msg);
-        var hram64: [Sha512.digest_length]u8 = undefined;
-        h.final(&hram64);
-        const hram = Curve.scalar.reduce64(hram64);
-
-        var x = az[0..32];
-        Curve.scalar.clamp(x);
-        const s = Curve.scalar.mulAdd(hram, x.*, nonce);
-        mem.copy(u8, sig[32..], s[0..]);
-        return sig;
-    }
-
-    /// Verify an Ed25519 signature given a message and a public key.
-    /// Returns error.SignatureVerificationFailed is the signature verification failed.
-    pub fn verify(sig: [signature_length]u8, msg: []const u8, public_key: [public_length]u8) (SignatureVerificationError || WeakPublicKeyError || EncodingError || NonCanonicalError || IdentityElementError)!void {
-        const r = sig[0..32];
-        const s = sig[32..64];
-        try Curve.scalar.rejectNonCanonical(s.*);
-        try Curve.rejectNonCanonical(public_key);
-        const a = try Curve.fromBytes(public_key);
-        try a.rejectIdentity();
-        try Curve.rejectNonCanonical(r.*);
-        const expected_r = try Curve.fromBytes(r.*);
-        try expected_r.rejectIdentity();
-
-        var h = Sha512.init(.{});
-        h.update(r);
-        h.update(&public_key);
-        h.update(msg);
-        var hram64: [Sha512.digest_length]u8 = undefined;
-        h.final(&hram64);
-        const hram = Curve.scalar.reduce64(hram64);
-
-        const sb_ah = try Curve.basePoint.mulDoubleBasePublic(s.*, a.neg(), hram);
-        if (expected_r.sub(sb_ah).clearCofactor().rejectIdentity()) |_| {
-            return error.SignatureVerificationFailed;
-        } else |_| {}
-    }
-
     /// A (signature, message, public_key) tuple for batch verification
     pub const BatchElement = struct {
-        sig: [signature_length]u8,
+        sig: Signature,
         msg: []const u8,
-        public_key: [public_length]u8,
+        public_key: PublicKey,
     };
 
     /// Verify several signatures in a single operation, much faster than verifying signatures one-by-one
     pub fn verifyBatch(comptime count: usize, signature_batch: [count]BatchElement) (SignatureVerificationError || IdentityElementError || WeakPublicKeyError || EncodingError || NonCanonicalError)!void {
-        var r_batch: [count][32]u8 = undefined;
-        var s_batch: [count][32]u8 = undefined;
+        var r_batch: [count]CompressedScalar = undefined;
+        var s_batch: [count]CompressedScalar = undefined;
         var a_batch: [count]Curve = undefined;
         var expected_r_batch: [count]Curve = undefined;
 
         for (signature_batch) |signature, i| {
-            const r = signature.sig[0..32];
-            const s = signature.sig[32..64];
-            try Curve.scalar.rejectNonCanonical(s.*);
-            try Curve.rejectNonCanonical(signature.public_key);
-            const a = try Curve.fromBytes(signature.public_key);
+            const r = signature.sig.r;
+            const s = signature.sig.s;
+            try Curve.scalar.rejectNonCanonical(s);
+            const a = try Curve.fromBytes(signature.public_key.bytes);
             try a.rejectIdentity();
-            try Curve.rejectNonCanonical(r.*);
-            const expected_r = try Curve.fromBytes(r.*);
+            try Curve.rejectNonCanonical(r);
+            const expected_r = try Curve.fromBytes(r);
             try expected_r.rejectIdentity();
             expected_r_batch[i] = expected_r;
-            r_batch[i] = r.*;
-            s_batch[i] = s.*;
+            r_batch[i] = r;
+            s_batch[i] = s;
             a_batch[i] = a;
         }
 
@@ -177,7 +358,7 @@ pub const Ed25519 = struct {
         for (signature_batch) |signature, i| {
             var h = Sha512.init(.{});
             h.update(&r_batch[i]);
-            h.update(&signature.public_key);
+            h.update(&signature.public_key.bytes);
             h.update(signature.msg);
             var hram64: [Sha512.digest_length]u8 = undefined;
             h.final(&hram64);
@@ -212,7 +393,7 @@ pub const Ed25519 = struct {
     }
 
     /// Ed25519 signatures with key blinding.
-    pub const BlindKeySignatures = struct {
+    pub const key_blinding = struct {
         /// Length (in bytes) of a blinding seed.
         pub const blind_seed_length = 32;
 
@@ -220,81 +401,69 @@ pub const Ed25519 = struct {
         pub const BlindSecretKey = struct {
             prefix: [64]u8,
             blind_scalar: CompressedScalar,
-            blind_public_key: CompressedScalar,
+            blind_public_key: BlindPublicKey,
+        };
+
+        /// A blind public key.
+        pub const BlindPublicKey = struct {
+            /// Public key equivalent, that can used for signature verification.
+            key: PublicKey,
+
+            /// Recover a public key from a blind version of it.
+            pub fn unblind(blind_public_key: BlindPublicKey, blind_seed: [blind_seed_length]u8, ctx: []const u8) (IdentityElementError || NonCanonicalError || EncodingError || WeakPublicKeyError)!PublicKey {
+                const blind_h = blindCtx(blind_seed, ctx);
+                const inv_blind_factor = Scalar.fromBytes(blind_h[0..32].*).invert().toBytes();
+                const pk_p = try (try Curve.fromBytes(blind_public_key.key.bytes)).mul(inv_blind_factor);
+                return PublicKey.fromBytes(pk_p.toBytes());
+            }
         };
 
         /// A blind key pair.
         pub const BlindKeyPair = struct {
-            blind_public_key: [public_length]u8,
+            blind_public_key: BlindPublicKey,
             blind_secret_key: BlindSecretKey,
-        };
 
-        /// Blind an existing key pair with a blinding seed and a context.
-        pub fn blind(key_pair: Ed25519.KeyPair, blind_seed: [blind_seed_length]u8, ctx: []const u8) !BlindKeyPair {
-            var h: [Sha512.digest_length]u8 = undefined;
-            Sha512.hash(key_pair.secret_key[0..32], &h, .{});
-            Curve.scalar.clamp(h[0..32]);
-            const scalar = Curve.scalar.reduce(h[0..32].*);
+            /// Create an blind key pair from an existing key pair, a blinding seed and a context.
+            pub fn init(key_pair: Ed25519.KeyPair, blind_seed: [blind_seed_length]u8, ctx: []const u8) (NonCanonicalError || IdentityElementError)!BlindKeyPair {
+                var h: [Sha512.digest_length]u8 = undefined;
+                Sha512.hash(&key_pair.secret_key.seed(), &h, .{});
+                Curve.scalar.clamp(h[0..32]);
+                const scalar = Curve.scalar.reduce(h[0..32].*);
 
-            const blind_h = blindCtx(blind_seed, ctx);
-            const blind_factor = Curve.scalar.reduce(blind_h[0..32].*);
+                const blind_h = blindCtx(blind_seed, ctx);
+                const blind_factor = Curve.scalar.reduce(blind_h[0..32].*);
 
-            const blind_scalar = Curve.scalar.mul(scalar, blind_factor);
-            const blind_public_key = (Curve.basePoint.mul(blind_scalar) catch return error.IdentityElement).toBytes();
+                const blind_scalar = Curve.scalar.mul(scalar, blind_factor);
+                const blind_public_key = BlindPublicKey{
+                    .key = try PublicKey.fromBytes((Curve.basePoint.mul(blind_scalar) catch return error.IdentityElement).toBytes()),
+                };
 
-            var prefix: [64]u8 = undefined;
-            mem.copy(u8, prefix[0..32], h[32..64]);
-            mem.copy(u8, prefix[32..64], blind_h[32..64]);
+                var prefix: [64]u8 = undefined;
+                mem.copy(u8, prefix[0..32], h[32..64]);
+                mem.copy(u8, prefix[32..64], blind_h[32..64]);
 
-            const blind_secret_key = .{
-                .prefix = prefix,
-                .blind_scalar = blind_scalar,
-                .blind_public_key = blind_public_key,
-            };
-            return BlindKeyPair{
-                .blind_public_key = blind_public_key,
-                .blind_secret_key = blind_secret_key,
-            };
-        }
-
-        /// Recover a public key from a blind version of it.
-        pub fn unblindPublicKey(blind_public_key: [public_length]u8, blind_seed: [blind_seed_length]u8, ctx: []const u8) ![public_length]u8 {
-            const blind_h = blindCtx(blind_seed, ctx);
-            const inv_blind_factor = Scalar.fromBytes(blind_h[0..32].*).invert().toBytes();
-            const public_key = try (try Curve.fromBytes(blind_public_key)).mul(inv_blind_factor);
-            return public_key.toBytes();
-        }
-
-        /// Sign a message using a blind key pair, and optional random noise.
-        /// Having noise creates non-standard, non-deterministic signatures,
-        /// but has been proven to increase resilience against fault attacks.
-        pub fn sign(msg: []const u8, key_pair: BlindKeyPair, noise: ?[noise_length]u8) ![signature_length]u8 {
-            var h = Sha512.init(.{});
-            if (noise) |*z| {
-                h.update(z);
+                const blind_secret_key = BlindSecretKey{
+                    .prefix = prefix,
+                    .blind_scalar = blind_scalar,
+                    .blind_public_key = blind_public_key,
+                };
+                return BlindKeyPair{
+                    .blind_public_key = blind_public_key,
+                    .blind_secret_key = blind_secret_key,
+                };
             }
-            h.update(&key_pair.blind_secret_key.prefix);
-            h.update(msg);
-            var nonce64: [64]u8 = undefined;
-            h.final(&nonce64);
 
-            const nonce = Curve.scalar.reduce64(nonce64);
-            const r = try Curve.basePoint.mul(nonce);
+            /// Sign a message using a blind key pair, and optional random noise.
+            /// Having noise creates non-standard, non-deterministic signatures,
+            /// but has been proven to increase resilience against fault attacks.
+            pub fn sign(key_pair: BlindKeyPair, msg: []const u8, noise: ?[noise_length]u8) (IdentityElementError || KeyMismatchError || NonCanonicalError || WeakPublicKeyError)!Signature {
+                const scalar = key_pair.blind_secret_key.blind_scalar;
+                const prefix = key_pair.blind_secret_key.prefix;
 
-            var sig: [signature_length]u8 = undefined;
-            mem.copy(u8, sig[0..32], &r.toBytes());
-            mem.copy(u8, sig[32..], &key_pair.blind_public_key);
-            h = Sha512.init(.{});
-            h.update(&sig);
-            h.update(msg);
-            var hram64: [Sha512.digest_length]u8 = undefined;
-            h.final(&hram64);
-            const hram = Curve.scalar.reduce64(hram64);
-
-            const s = Curve.scalar.mulAdd(hram, key_pair.blind_secret_key.blind_scalar, nonce);
-            mem.copy(u8, sig[32..], s[0..]);
-            return sig;
-        }
+                return (try PublicKey.fromBytes(key_pair.blind_public_key.key.bytes))
+                    .computeNonceAndSign(msg, noise, scalar, &prefix);
+            }
+        };
 
         /// Compute a blind context from a blinding seed and a context.
         fn blindCtx(blind_seed: [blind_seed_length]u8, ctx: []const u8) [Sha512.digest_length]u8 {
@@ -306,7 +475,13 @@ pub const Ed25519 = struct {
             hx.final(&blind_h);
             return blind_h;
         }
+
+        pub const sign = @compileError("deprecated; use BlindKeyPair.sign instead");
+        pub const unblindPublicKey = @compileError("deprecated; use BlindPublicKey.unblind instead");
     };
+
+    pub const sign = @compileError("deprecated; use KeyPair.sign instead");
+    pub const verify = @compileError("deprecated; use PublicKey.verify instead");
 };
 
 test "ed25519 key pair creation" {
@@ -314,8 +489,8 @@ test "ed25519 key pair creation" {
     _ = try fmt.hexToBytes(seed[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");
     const key_pair = try Ed25519.KeyPair.create(seed);
     var buf: [256]u8 = undefined;
-    try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&key_pair.secret_key)}), "8052030376D47112BE7F73ED7A019293DD12AD910B654455798B4667D73DE1662D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083");
-    try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&key_pair.public_key)}), "2D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083");
+    try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&key_pair.secret_key.toBytes())}), "8052030376D47112BE7F73ED7A019293DD12AD910B654455798B4667D73DE1662D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083");
+    try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&key_pair.public_key.toBytes())}), "2D6F7455D97B4A3A10D7293909D1A4F2058CB9A370E43FA8154BB280DB839083");
 }
 
 test "ed25519 signature" {
@@ -323,11 +498,11 @@ test "ed25519 signature" {
     _ = try fmt.hexToBytes(seed[0..], "8052030376d47112be7f73ed7a019293dd12ad910b654455798b4667d73de166");
     const key_pair = try Ed25519.KeyPair.create(seed);
 
-    const sig = try Ed25519.sign("test", key_pair, null);
+    const sig = try key_pair.sign("test", null);
     var buf: [128]u8 = undefined;
-    try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&sig)}), "10A442B4A80CC4225B154F43BEF28D2472CA80221951262EB8E0DF9091575E2687CC486E77263C3418C757522D54F84B0359236ABBBD4ACD20DC297FDCA66808");
-    try Ed25519.verify(sig, "test", key_pair.public_key);
-    try std.testing.expectError(error.SignatureVerificationFailed, Ed25519.verify(sig, "TEST", key_pair.public_key));
+    try std.testing.expectEqualStrings(try std.fmt.bufPrint(&buf, "{s}", .{std.fmt.fmtSliceHexUpper(&sig.toBytes())}), "10A442B4A80CC4225B154F43BEF28D2472CA80221951262EB8E0DF9091575E2687CC486E77263C3418C757522D54F84B0359236ABBBD4ACD20DC297FDCA66808");
+    try sig.verify("test", key_pair.public_key);
+    try std.testing.expectError(error.SignatureVerificationFailed, sig.verify("TEST", key_pair.public_key));
 }
 
 test "ed25519 batch verification" {
@@ -338,8 +513,8 @@ test "ed25519 batch verification" {
         var msg2: [32]u8 = undefined;
         crypto.random.bytes(&msg1);
         crypto.random.bytes(&msg2);
-        const sig1 = try Ed25519.sign(&msg1, key_pair, null);
-        const sig2 = try Ed25519.sign(&msg2, key_pair, null);
+        const sig1 = try key_pair.sign(&msg1, null);
+        const sig2 = try key_pair.sign(&msg2, null);
         var signature_batch = [_]Ed25519.BatchElement{
             Ed25519.BatchElement{
                 .sig = sig1,
@@ -355,9 +530,7 @@ test "ed25519 batch verification" {
         try Ed25519.verifyBatch(2, signature_batch);
 
         signature_batch[1].sig = sig1;
-        // TODO https://github.com/ziglang/zig/issues/12240
-        const sig_len = signature_batch.len;
-        try std.testing.expectError(error.SignatureVerificationFailed, Ed25519.verifyBatch(sig_len, signature_batch));
+        try std.testing.expectError(error.SignatureVerificationFailed, Ed25519.verifyBatch(signature_batch.len, signature_batch));
     }
 }
 
@@ -446,20 +619,25 @@ test "ed25519 test vectors" {
     for (entries) |entry| {
         var msg: [entry.msg_hex.len / 2]u8 = undefined;
         _ = try fmt.hexToBytes(&msg, entry.msg_hex);
-        var public_key: [32]u8 = undefined;
-        _ = try fmt.hexToBytes(&public_key, entry.public_key_hex);
-        var sig: [64]u8 = undefined;
-        _ = try fmt.hexToBytes(&sig, entry.sig_hex);
+        var public_key_bytes: [32]u8 = undefined;
+        _ = try fmt.hexToBytes(&public_key_bytes, entry.public_key_hex);
+        const public_key = Ed25519.PublicKey.fromBytes(public_key_bytes) catch |err| {
+            try std.testing.expectEqual(entry.expected.?, err);
+            continue;
+        };
+        var sig_bytes: [64]u8 = undefined;
+        _ = try fmt.hexToBytes(&sig_bytes, entry.sig_hex);
+        const sig = Ed25519.Signature.fromBytes(sig_bytes);
         if (entry.expected) |error_type| {
-            try std.testing.expectError(error_type, Ed25519.verify(sig, &msg, public_key));
+            try std.testing.expectError(error_type, sig.verify(&msg, public_key));
         } else {
-            try Ed25519.verify(sig, &msg, public_key);
+            try sig.verify(&msg, public_key);
         }
     }
 }
 
 test "ed25519 with blind keys" {
-    const BlindKeySignatures = Ed25519.BlindKeySignatures;
+    const BlindKeyPair = Ed25519.key_blinding.BlindKeyPair;
 
     // Create a standard Ed25519 key pair
     const kp = try Ed25519.KeyPair.create(null);
@@ -469,14 +647,30 @@ test "ed25519 with blind keys" {
     crypto.random.bytes(&blind);
 
     // Blind the key pair
-    const blind_kp = try BlindKeySignatures.blind(kp, blind, "ctx");
+    const blind_kp = try BlindKeyPair.init(kp, blind, "ctx");
 
     // Sign a message and check that it can be verified with the blind public key
     const msg = "test";
-    const sig = try BlindKeySignatures.sign(msg, blind_kp, null);
-    try Ed25519.verify(sig, msg, blind_kp.blind_public_key);
+    const sig = try blind_kp.sign(msg, null);
+    try sig.verify(msg, blind_kp.blind_public_key.key);
 
     // Unblind the public key
-    const pk = try BlindKeySignatures.unblindPublicKey(blind_kp.blind_public_key, blind, "ctx");
-    try std.testing.expectEqualSlices(u8, &pk, &kp.public_key);
+    const pk = try blind_kp.blind_public_key.unblind(blind, "ctx");
+    try std.testing.expectEqualSlices(u8, &pk.toBytes(), &kp.public_key.toBytes());
+}
+
+test "ed25519 signatures with streaming" {
+    const kp = try Ed25519.KeyPair.create(null);
+
+    var signer = try kp.signer(null);
+    signer.update("mes");
+    signer.update("sage");
+    const sig = signer.finalize();
+
+    try sig.verify("message", kp.public_key);
+
+    var verifier = try sig.verifier(kp.public_key);
+    verifier.update("mess");
+    verifier.update("age");
+    try verifier.verify();
 }
diff --git a/lib/std/crypto/25519/x25519.zig b/lib/std/crypto/25519/x25519.zig
index d935513ab6..22bcf00136 100644
--- a/lib/std/crypto/25519/x25519.zig
+++ b/lib/std/crypto/25519/x25519.zig
@@ -44,9 +44,9 @@ pub const X25519 = struct {
 
         /// Create a key pair from an Ed25519 key pair
         pub fn fromEd25519(ed25519_key_pair: crypto.sign.Ed25519.KeyPair) (IdentityElementError || EncodingError)!KeyPair {
-            const seed = ed25519_key_pair.secret_key[0..32];
+            const seed = ed25519_key_pair.secret_key.seed();
             var az: [Sha512.digest_length]u8 = undefined;
-            Sha512.hash(seed, &az, .{});
+            Sha512.hash(&seed, &az, .{});
             var sk = az[0..32].*;
             Curve.scalar.clamp(&sk);
             const pk = try publicKeyFromEd25519(ed25519_key_pair.public_key);
@@ -64,8 +64,8 @@ pub const X25519 = struct {
     }
 
     /// Compute the X25519 equivalent to an Ed25519 public eky.
-    pub fn publicKeyFromEd25519(ed25519_public_key: [crypto.sign.Ed25519.public_length]u8) (IdentityElementError || EncodingError)![public_length]u8 {
-        const pk_ed = try crypto.ecc.Edwards25519.fromBytes(ed25519_public_key);
+    pub fn publicKeyFromEd25519(ed25519_public_key: crypto.sign.Ed25519.PublicKey) (IdentityElementError || EncodingError)![public_length]u8 {
+        const pk_ed = try crypto.ecc.Edwards25519.fromBytes(ed25519_public_key.bytes);
         const pk = try Curve.fromEdwards25519(pk_ed);
         return pk.toBytes();
     }
diff --git a/lib/std/crypto/benchmark.zig b/lib/std/crypto/benchmark.zig
index 28d283048a..d4bf3d2633 100644
--- a/lib/std/crypto/benchmark.zig
+++ b/lib/std/crypto/benchmark.zig
@@ -130,7 +130,7 @@ pub fn benchmarkSignature(comptime Signature: anytype, comptime signatures_count
     {
         var i: usize = 0;
         while (i < signatures_count) : (i += 1) {
-            const sig = try Signature.sign(&msg, key_pair, null);
+            const sig = try key_pair.sign(&msg, null);
             mem.doNotOptimizeAway(&sig);
         }
     }
@@ -147,14 +147,14 @@ const signature_verifications = [_]Crypto{Crypto{ .ty = crypto.sign.Ed25519, .na
 pub fn benchmarkSignatureVerification(comptime Signature: anytype, comptime signatures_count: comptime_int) !u64 {
     const msg = [_]u8{0} ** 64;
     const key_pair = try Signature.KeyPair.create(null);
-    const sig = try Signature.sign(&msg, key_pair, null);
+    const sig = try key_pair.sign(&msg, null);
 
     var timer = try Timer.start();
     const start = timer.lap();
     {
         var i: usize = 0;
         while (i < signatures_count) : (i += 1) {
-            try Signature.verify(sig, &msg, key_pair.public_key);
+            try sig.verify(&msg, key_pair.public_key);
             mem.doNotOptimizeAway(&sig);
         }
     }
@@ -171,7 +171,7 @@ const batch_signature_verifications = [_]Crypto{Crypto{ .ty = crypto.sign.Ed2551
 pub fn benchmarkBatchSignatureVerification(comptime Signature: anytype, comptime signatures_count: comptime_int) !u64 {
     const msg = [_]u8{0} ** 64;
     const key_pair = try Signature.KeyPair.create(null);
-    const sig = try Signature.sign(&msg, key_pair, null);
+    const sig = try key_pair.sign(&msg, null);
 
     var batch: [64]Signature.BatchElement = undefined;
     for (batch) |*element| {
@@ -301,9 +301,13 @@ const CryptoPwhash = struct {
     params: *const anyopaque,
     name: []const u8,
 };
-const bcrypt_params = crypto.pwhash.bcrypt.Params{ .rounds_log = 12 };
+const bcrypt_params = crypto.pwhash.bcrypt.Params{ .rounds_log = 8 };
 const pwhashes = [_]CryptoPwhash{
-    .{ .ty = crypto.pwhash.bcrypt, .params = &bcrypt_params, .name = "bcrypt" },
+    .{
+        .ty = crypto.pwhash.bcrypt,
+        .params = &bcrypt_params,
+        .name = "bcrypt",
+    },
     .{
         .ty = crypto.pwhash.scrypt,
         .params = &crypto.pwhash.scrypt.Params.interactive,
@@ -323,7 +327,11 @@ fn benchmarkPwhash(
     comptime count: comptime_int,
 ) !f64 {
     const password = "testpass" ** 2;
-    const opts = .{ .allocator = allocator, .params = @ptrCast(*const ty.Params, params).*, .encoding = .phc };
+    const opts = .{
+        .allocator = allocator,
+        .params = @ptrCast(*const ty.Params, @alignCast(std.meta.alignment(ty.Params), params)).*,
+        .encoding = .phc,
+    };
     var buf: [256]u8 = undefined;
 
     var timer = try Timer.start();

From f4f4e3388586e0c2e19d794725359e1b591f9a3e Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 27 Oct 2022 12:32:32 -0700
Subject: [PATCH 45/70] github: simplify bug issue template

---
 .github/ISSUE_TEMPLATE/bug.yml | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

diff --git a/.github/ISSUE_TEMPLATE/bug.yml b/.github/ISSUE_TEMPLATE/bug.yml
index 31fb479b56..5560b2412d 100644
--- a/.github/ISSUE_TEMPLATE/bug.yml
+++ b/.github/ISSUE_TEMPLATE/bug.yml
@@ -14,27 +14,20 @@ body:
     attributes:
       label: Zig Version
       description: "The output of `zig version`"
-      placeholder: "0.9.0-dev.1275+ac52e0056"
+      placeholder: "0.10.0-dev.4583+875e98a57"
     validations:
       required: true
   - type: textarea
     id: repro
     attributes:
-      label: Steps to Reproduce
-      description: What exactly can someone else do, in order to observe the problem that you observed?
+      label: Steps to Reproduce and Observed Behavior
+      description: What exactly can someone else do, in order to observe the problem that you observed? Include the output and all error messages.
     validations:
       required: true
   - type: textarea
     id: expected
     attributes:
       label: Expected Behavior
-      description: What did you expect to happen?
-    validations:
-      required: true
-  - type: textarea
-    id: actual
-    attributes:
-      label: Actual Behavior
-      description: What happened instead? Be sure to include all error messages if any.
+      description: What did you expect to happen instead?
     validations:
       required: true

From 0b99e5e4c42f3c9711f3a119711d584fa32a92a1 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 27 Oct 2022 15:16:14 -0700
Subject: [PATCH 46/70] build: rename the "skip lib files" option

 * Old cmake option: `-DZIG_SKIP_INSTALL_LIB_FILES=ON`
 * New cmake option: `-DZIG_NO_LIB=ON`
 * Old build.zig option: `-Dskip-install-lib-files`
 * New build.zig option: `-Dno-lib`

Motivation is making build commands easier to type.
---
 .github/CONTRIBUTING.md |  2 +-
 CMakeLists.txt          | 16 +++++++++++-----
 build.zig               |  6 +++++-
 3 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index 179ebf0bf4..9a05b2b0f1 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -68,7 +68,7 @@ test and debug from a git working tree.
 - `make` is typically sufficient to build zig during development iterations.
 - `make install` performs a build __and__ install.
 - `msbuild -p:Configuration=Release INSTALL.vcxproj` on Windows performs a
-build and install. To avoid install, pass cmake option `-DZIG_SKIP_INSTALL_LIB_FILES=ON`.
+build and install. To avoid install, pass cmake option `-DZIG_NO_LIB=ON`.
 
 To test changes, do the following from the build directory:
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3be09c028e..943aae331a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -81,9 +81,15 @@ if("${ZIG_VERSION}" STREQUAL "")
 endif()
 message(STATUS "Configuring zig version ${ZIG_VERSION}")
 
-set(ZIG_SKIP_INSTALL_LIB_FILES off CACHE BOOL
+set(ZIG_NO_LIB off CACHE BOOL
     "Disable copying lib/ files to install prefix during the build phase")
 
+set(ZIG_SKIP_INSTALL_LIB_FILES off CACHE BOOL "Deprecated. Use ZIG_NO_LIB")
+if(ZIG_SKIP_INSTALL_LIB_FILES)
+  message(WARNING "ZIG_SKIP_INSTALL_LIB_FILES is deprecated. Use ZIG_NO_LIB instead.")
+  set(ZIG_NO_LIB ON)
+endif()
+
 set(ZIG_STATIC off CACHE BOOL "Attempt to build a static zig executable (not compatible with glibc)")
 set(ZIG_SHARED_LLVM off CACHE BOOL "Prefer linking against shared LLVM libraries")
 set(ZIG_STATIC_LLVM off CACHE BOOL "Prefer linking against static LLVM libraries")
@@ -1004,10 +1010,10 @@ elseif("${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo")
 else()
   set(ZIG_RELEASE_ARG -Drelease -Dstrip)
 endif()
-if(ZIG_SKIP_INSTALL_LIB_FILES)
-  set(ZIG_SKIP_INSTALL_LIB_FILES_ARG "-Dskip-install-lib-files")
+if(ZIG_NO_LIB)
+  set(ZIG_NO_LIB_ARG "-Dno-lib")
 else()
-  set(ZIG_SKIP_INSTALL_LIB_FILES_ARG "-Dskip-install-lib-files=false")
+  set(ZIG_NO_LIB_ARG "")
 endif()
 if(ZIG_SINGLE_THREADED)
   set(ZIG_SINGLE_THREADED_ARG "-fsingle-threaded")
@@ -1080,7 +1086,7 @@ set(ZIG_BUILD_ARGS
     "-Denable-stage1"
     ${ZIG_RELEASE_ARG}
     ${ZIG_STATIC_ARG}
-    ${ZIG_SKIP_INSTALL_LIB_FILES_ARG}
+    ${ZIG_NO_LIB_ARG}
     ${ZIG_SINGLE_THREADED_ARG}
     "-Dtarget=${ZIG_TARGET_TRIPLE}"
     "-Dcpu=${ZIG_TARGET_MCPU}"
diff --git a/build.zig b/build.zig
index e439b9cb33..293621e545 100644
--- a/build.zig
+++ b/build.zig
@@ -61,7 +61,11 @@ pub fn build(b: *Builder) !void {
     const skip_stage1 = b.option(bool, "skip-stage1", "Main test suite skips stage1 compile error tests") orelse false;
     const skip_run_translated_c = b.option(bool, "skip-run-translated-c", "Main test suite skips run-translated-c tests") orelse false;
     const skip_stage2_tests = b.option(bool, "skip-stage2-tests", "Main test suite skips self-hosted compiler tests") orelse false;
-    const skip_install_lib_files = b.option(bool, "skip-install-lib-files", "Do not copy lib/ files to installation prefix") orelse false;
+    const deprecated_skip_install_lib_files = b.option(bool, "skip-install-lib-files", "deprecated. see no-lib") orelse false;
+    if (deprecated_skip_install_lib_files) {
+        std.log.warn("-Dskip-install-lib-files is deprecated in favor of -Dno-lib", .{});
+    }
+    const skip_install_lib_files = b.option(bool, "no-lib", "skip copying of lib/ files to installation prefix. Useful for development") orelse deprecated_skip_install_lib_files;
 
     const only_install_lib_files = b.option(bool, "lib-files-only", "Only install library files") orelse false;
 

From c0c8ee5ae9a3ddd78d94166caaa75d88d0fe8c15 Mon Sep 17 00:00:00 2001
From: daurnimator <quae@daurnimator.com>
Date: Thu, 27 Oct 2022 22:25:48 +1100
Subject: [PATCH 47/70] Add reboot syscall

Only linux for now
---
 lib/std/os.zig       | 50 ++++++++++++++++++++++++++++++++++++++
 lib/std/os/linux.zig | 57 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 107 insertions(+)

diff --git a/lib/std/os.zig b/lib/std/os.zig
index 74ffd4de12..e69a2a7943 100644
--- a/lib/std/os.zig
+++ b/lib/std/os.zig
@@ -366,6 +366,56 @@ pub fn fchown(fd: fd_t, owner: ?uid_t, group: ?gid_t) FChownError!void {
     }
 }
 
+pub const RebootError = error{
+    PermissionDenied,
+} || UnexpectedError;
+
+pub const RebootCommand = switch (builtin.os.tag) {
+    .linux => union(linux.LINUX_REBOOT.CMD) {
+        RESTART: void,
+        HALT: void,
+        CAD_ON: void,
+        CAD_OFF: void,
+        POWER_OFF: void,
+        RESTART2: [*:0]const u8,
+        SW_SUSPEND: void,
+        KEXEC: void,
+    },
+    else => @compileError("Unsupported OS"),
+};
+
+pub fn reboot(cmd: RebootCommand) RebootError!void {
+    switch (builtin.os.tag) {
+        .linux => {
+            switch (system.getErrno(linux.reboot(
+                .MAGIC1,
+                .MAGIC2,
+                @as(linux.LINUX_REBOOT.CMD, cmd),
+                switch (cmd) {
+                    .RESTART2 => |s| s,
+                    else => null,
+                },
+            ))) {
+                .SUCCESS => {},
+                .PERM => return error.PermissionDenied,
+                else => |err| return std.os.unexpectedErrno(err),
+            }
+            switch (cmd) {
+                .CAD_OFF => {},
+                .CAD_ON => {},
+                .SW_SUSPEND => {},
+
+                .HALT => unreachable,
+                .KEXEC => unreachable,
+                .POWER_OFF => unreachable,
+                .RESTART => unreachable,
+                .RESTART2 => unreachable,
+            }
+        },
+        else => @compileError("Unsupported OS"),
+    }
+}
+
 pub const GetRandomError = OpenError;
 
 /// Obtain a series of random bytes. These bytes can be used to seed user-space
diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index 8ca20bc330..f98cd828c0 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -804,6 +804,63 @@ pub fn exit_group(status: i32) noreturn {
     unreachable;
 }
 
+/// flags for the `reboot' system call.
+pub const LINUX_REBOOT = struct {
+    /// First magic value required to use _reboot() system call.
+    pub const MAGIC1 = enum(u32) {
+        MAGIC1 = 0xfee1dead,
+        _,
+    };
+
+    /// Second magic value required to use _reboot() system call.
+    pub const MAGIC2 = enum(u32) {
+        MAGIC2 = 672274793,
+        MAGIC2A = 85072278,
+        MAGIC2B = 369367448,
+        MAGIC2C = 537993216,
+        _,
+    };
+
+    /// Commands accepted by the _reboot() system call.
+    pub const CMD = enum(u32) {
+        /// Restart system using default command and mode.
+        RESTART = 0x01234567,
+
+        /// Stop OS and give system control to ROM monitor, if any.
+        HALT = 0xCDEF0123,
+
+        /// Ctrl-Alt-Del sequence causes RESTART command.
+        CAD_ON = 0x89ABCDEF,
+
+        /// Ctrl-Alt-Del sequence sends SIGINT to init task.
+        CAD_OFF = 0x00000000,
+
+        /// Stop OS and remove all power from system, if possible.
+        POWER_OFF = 0x4321FEDC,
+
+        /// Restart system using given command string.
+        RESTART2 = 0xA1B2C3D4,
+
+        /// Suspend system using software suspend if compiled in.
+        SW_SUSPEND = 0xD000FCE2,
+
+        /// Restart system using a previously loaded Linux kernel
+        KEXEC = 0x45584543,
+
+        _,
+    };
+};
+
+pub fn reboot(magic: LINUX_REBOOT.MAGIC1, magic2: LINUX_REBOOT.MAGIC2, cmd: LINUX_REBOOT.CMD, arg: ?*const anyopaque) usize {
+    return std.os.linux.syscall4(
+        .reboot,
+        @enumToInt(magic),
+        @enumToInt(magic2),
+        @enumToInt(cmd),
+        @ptrToInt(arg),
+    );
+}
+
 pub fn getrandom(buf: [*]u8, count: usize, flags: u32) usize {
     return syscall3(.getrandom, @ptrToInt(buf), count, flags);
 }

From f2401a07569b375aae77600755fb8e2ca615e93c Mon Sep 17 00:00:00 2001
From: daurnimator <quae@daurnimator.com>
Date: Thu, 27 Oct 2022 22:36:27 +1100
Subject: [PATCH 48/70] Add sockaddr_vm for vSocckets on Linux

---
 lib/std/os/linux.zig | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig
index f98cd828c0..da9ea74327 100644
--- a/lib/std/os/linux.zig
+++ b/lib/std/os/linux.zig
@@ -3265,6 +3265,21 @@ pub const sockaddr = extern struct {
         queue_id: u32,
         shared_umem_fd: u32,
     };
+
+    /// Address structure for vSockets
+    pub const vm = extern struct {
+        family: sa_family_t = AF.VSOCK,
+        reserved1: u16 = 0,
+        port: u32,
+        cid: u32,
+        flags: u8,
+
+        /// The total size of this structure should be exactly the same as that of struct sockaddr.
+        zero: [3]u8 = [_]u8{0} ** 3,
+        comptime {
+            std.debug.assert(@sizeOf(vm) == @sizeOf(sockaddr));
+        }
+    };
 };
 
 pub const mmsghdr = extern struct {

From 398a3aae40bc03f6b7c6cd86d78a4cde125f2811 Mon Sep 17 00:00:00 2001
From: Eric Joldasov <bratishkaerik@getgoogleoff.me>
Date: Wed, 26 Oct 2022 11:42:17 +0600
Subject: [PATCH 49/70] CI: make directory structure in releases consistent

---
 ci/azure/macos_script             | 18 ++++++++++++++++--
 ci/azure/pipelines.yml            | 26 ++++++++++++++++++--------
 ci/drone/linux_script_finalize    | 13 ++++++++++---
 ci/drone/test_linux_std_Debug     |  7 +++++++
 ci/srht/freebsd_script            | 18 ++++++++++++++++--
 ci/srht/update_download_page      | 10 +++++-----
 ci/zinc/linux_test_stage3_release |  8 ++++----
 ci/zinc/macos_package             |  2 +-
 8 files changed, 77 insertions(+), 25 deletions(-)

diff --git a/ci/azure/macos_script b/ci/azure/macos_script
index a75809fa8b..a8abc48678 100755
--- a/ci/azure/macos_script
+++ b/ci/azure/macos_script
@@ -55,12 +55,26 @@ stage3-release/bin/zig build test docs \
   -Dskip-non-native \
   --search-prefix "$PREFIX"
 
+# Produce the experimental std lib documentation.
+mkdir -p "stage3-release/doc/std"
+stage3-release/bin/zig test "$(pwd)/../lib/std/std.zig" \
+  --zig-lib-dir "$(pwd)/../lib" \
+  -femit-docs="$(pwd)/stage3-release/doc/std" \
+  -fno-emit-bin
+
 if [ "${BUILD_REASON}" != "PullRequest" ]; then
-  mv ../LICENSE stage3-release/
-  mv ../zig-cache/langref.html stage3-release/
+  # Remove the unnecessary bin dir in stage3-release/bin/zig
   mv stage3-release/bin/zig stage3-release/
   rmdir stage3-release/bin
 
+  # Remove the unnecessary zig dir in stage3-release/lib/zig/std/std.zig
+  mv stage3-release/lib/zig stage3-release/lib2
+  rmdir stage3-release/lib
+  mv stage3-release/lib2 stage3-release/lib
+
+  mv ../LICENSE stage3-release/
+  mv ../zig-cache/langref.html stage3-release/doc
+
   VERSION=$(stage3-release/zig version)
   DIRNAME="zig-macos-$ARCH-$VERSION"
   TARBALL="$DIRNAME.tar.xz"
diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index cedc33c8b5..f9ab3dff2b 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -60,6 +60,7 @@ jobs:
     displayName: 'Build'
 
   - pwsh: |
+      Set-Variable -Name ZIGLIBDIR -Value "$(Get-Location)\lib"
       Set-Variable -Name ZIGINSTALLDIR -Value "$(Get-Location)\stage3-release"
       Set-Variable -Name ZIGPREFIXPATH -Value "$(Get-Location)\$(ZIG_LLVM_CLANG_LLD_NAME)"
 
@@ -75,6 +76,14 @@ jobs:
         -Dstatic-llvm `
         -Dskip-non-native
       CheckLastExitCode
+
+      # Produce the experimental std lib documentation.
+      mkdir "$ZIGINSTALLDIR\doc\std" -force
+      & "$ZIGINSTALLDIR\bin\zig.exe" test "$ZIGLIBDIR\std\std.zig" `
+        --zig-lib-dir "$ZIGLIBDIR" `
+        -femit-docs="$ZIGINSTALLDIR\doc\std" `
+        -fno-emit-bin
+
     name: test
     displayName: 'Test'
 
@@ -84,6 +93,7 @@ jobs:
       secureFile: aws_credentials
 
   - pwsh: |
+      Set-Variable -Name ZIGINSTALLDIR -Value "$(Get-Location)\stage3-release"
       $Env:AWS_SHARED_CREDENTIALS_FILE = "$Env:DOWNLOADSECUREFILE_SECUREFILEPATH"
 
       # Workaround Azure networking issue
@@ -91,15 +101,15 @@ jobs:
       $Env:AWS_EC2_METADATA_DISABLED = "true"
       $Env:AWS_REGION = "us-west-2"
 
-      mv LICENSE stage3-release/
-      mv zig-cache/langref.html stage3-release/
-      mv stage3-release/bin/zig.exe stage3-release/
-      rmdir stage3-release/bin
+      mv LICENSE "$ZIGINSTALLDIR"
+      mv zig-cache/langref.html "$ZIGINSTALLDIR"
+      mv "$ZIGINSTALLDIR\bin\zig.exe" "$ZIGINSTALLDIR\doc\"
+      rmdir "$ZIGINSTALLDIR/bin"
 
-      # Remove the unnecessary zig dir in $prefix/lib/zig/std/std.zig
-      mv stage3-release/lib/zig stage3-release/lib2
-      rmdir stage3-release/lib
-      mv stage3-release/lib2 stage3-release/lib
+      # Remove the unnecessary zig dir in $ZIGINSTALLDIR\lib\zig\std\std.zig
+      mv "$ZIGINSTALLDIR\lib\zig" "$ZIGINSTALLDIR\lib2"
+      rmdir "$ZIGINSTALLDIR\lib"
+      mv "$ZIGINSTALLDIR\lib2" "$ZIGINSTALLDIR\lib"
 
       Set-Variable -Name VERSION -Value $(./stage3-release/zig.exe version)
       Set-Variable -Name DIRNAME -Value "zig-windows-x86_64-$VERSION"
diff --git a/ci/drone/linux_script_finalize b/ci/drone/linux_script_finalize
index 5f021fbaa5..4cbff2ddf6 100755
--- a/ci/drone/linux_script_finalize
+++ b/ci/drone/linux_script_finalize
@@ -14,12 +14,19 @@ fi
 
 cd build
 
-mv ../LICENSE "$INSTALL_PREFIX/"
-# https://github.com/ziglang/zig/issues/12689
-# mv ../zig-cache/langref.html "$INSTALL_PREFIX/"
+# Remove the unnecessary bin dir in $INSTALL_PREFIX/bin/zig
 mv "$INSTALL_PREFIX/bin/zig" "$INSTALL_PREFIX/"
 rmdir "$INSTALL_PREFIX/bin"
 
+# Remove the unnecessary zig dir in $INSTALL_PREFIX/lib/zig/std/std.zig
+mv "$INSTALL_PREFIX/lib/zig" "$INSTALL_PREFIX/lib2"
+rmdir "$INSTALL_PREFIX/lib"
+mv "$INSTALL_PREFIX/lib2" "$INSTALL_PREFIX/lib"
+
+mv ../LICENSE "$INSTALL_PREFIX/"
+# https://github.com/ziglang/zig/issues/12689
+# mv ../zig-cache/langref.html "$INSTALL_PREFIX/doc/"
+
 GITBRANCH="$DRONE_BRANCH"
 VERSION="$("$INSTALL_PREFIX/zig" version)"
 DIRNAME="zig-linux-$ARCH-$VERSION"
diff --git a/ci/drone/test_linux_std_Debug b/ci/drone/test_linux_std_Debug
index 39558e19d1..bde270fd15 100755
--- a/ci/drone/test_linux_std_Debug
+++ b/ci/drone/test_linux_std_Debug
@@ -13,3 +13,10 @@ $ZIG build test-std \
   -Dskip-release-fast \
   -Dskip-release-small \
   -Dskip-non-native
+
+# Produce the experimental std lib documentation.
+mkdir -p "$INSTALL_PREFIX/doc/std"
+$ZIG test "$DRONE_WORKSPACE/lib/std/std.zig" \
+  --zig-lib-dir "$DRONE_WORKSPACE/lib" \
+  -femit-docs="$INSTALL_PREFIX/doc/std" \
+  -fno-emit-bin
diff --git a/ci/srht/freebsd_script b/ci/srht/freebsd_script
index 8cdb10c20c..b70a63f9cb 100755
--- a/ci/srht/freebsd_script
+++ b/ci/srht/freebsd_script
@@ -62,12 +62,26 @@ stage3/bin/zig build test docs \
   -Dskip-stage1 \
   -Dskip-non-native
 
+# Produce the experimental std lib documentation.
+mkdir -p "stage3/doc/std"
+stage3/bin/zig test "$(pwd)/../lib/std/std.zig" \
+  --zig-lib-dir "$(pwd)/../lib" \
+  -femit-docs="$(pwd)/stage3/doc/std/" \
+  -fno-emit-bin
+
 if [ -f ~/.s3cfg ]; then
-  mv ../LICENSE stage3/
-  mv ../zig-cache/langref.html stage3/
+  # Remove the unnecessary bin dir in stage3/bin/zig
   mv stage3/bin/zig stage3/
   rmdir stage3/bin
 
+  # Remove the unnecessary zig dir in stage3/lib/zig/std/std.zig
+  mv stage3/lib/zig stage3/lib2
+  rmdir stage3/lib
+  mv stage3/lib2 stage3/lib
+
+  mv ../LICENSE stage3/
+  mv ../zig-cache/langref.html stage3/doc/
+
   GITBRANCH=$(basename $GITHUB_REF)
   VERSION=$(stage3/zig version)
   DIRNAME="zig-freebsd-x86_64-$VERSION"
diff --git a/ci/srht/update_download_page b/ci/srht/update_download_page
index b6ff10bbaa..bad6c3c52b 100755
--- a/ci/srht/update_download_page
+++ b/ci/srht/update_download_page
@@ -48,7 +48,7 @@ wget "https://ziglang.org/builds/$NATIVE_TARBALL"
 tar xf "$NATIVE_TARBALL"
 ZIGDIR="$(pwd)/$(basename $NATIVE_TARBALL .tar.xz)"
 ZIG="$ZIGDIR/zig"
-LANGREF="$ZIGDIR/docs/langref.html"
+LANGREF="$ZIGDIR/doc/langref.html"
 SRCTARBALLDIR="zig-$VERSION"
 export SRC_TARBALL="$SRCTARBALLDIR.tar.xz"
 mv "$SRCDIR" "$SRCTARBALLDIR"
@@ -120,20 +120,20 @@ $S3CMD put -P --no-mime-magic \
 
 $S3CMD put -P --no-mime-magic \
   --add-header="Cache-Control: max-age=0, must-revalidate" \
-  "$ZIGDIR/docs/std/index.html" s3://ziglang.org/documentation/master/std/index.html
+  "$ZIGDIR/doc/std/index.html" s3://ziglang.org/documentation/master/std/index.html
 
 $S3CMD put -P --no-mime-magic \
   --add-header="Cache-Control: max-age=0, must-revalidate" \
-  "$ZIGDIR/docs/std/main.js" s3://ziglang.org/documentation/master/std/main.js
+  "$ZIGDIR/doc/std/main.js" s3://ziglang.org/documentation/master/std/main.js
 
 $S3CMD put -P --no-mime-magic \
   --add-header="Cache-Control: max-age=0, must-revalidate" \
-  "$ZIGDIR/docs/std/data.js" s3://ziglang.org/documentation/master/std/data.js
+  "$ZIGDIR/doc/std/data.js" s3://ziglang.org/documentation/master/std/data.js
 
 $S3CMD put -P --no-mime-magic --recursive \
   --add-header="Cache-Control: max-age=0, must-revalidate" \
   -m "text/html" \
-  "$ZIGDIR/docs/std/src/" s3://ziglang.org/documentation/master/std/src/
+  "$ZIGDIR/doc/std/src/" s3://ziglang.org/documentation/master/std/src/
 
 $S3CMD put -P --no-mime-magic \
   --add-header="cache-control: public, max-age=31536000, immutable" \
diff --git a/ci/zinc/linux_test_stage3_release b/ci/zinc/linux_test_stage3_release
index 63883a3948..327c9ab081 100755
--- a/ci/zinc/linux_test_stage3_release
+++ b/ci/zinc/linux_test_stage3_release
@@ -44,17 +44,17 @@ ninja install
   --zig-lib-dir "$(pwd)/../lib"
 
 # Produce the experimental std lib documentation.
-mkdir -p "$RELEASE_STAGING/docs/std"
+mkdir -p "$RELEASE_STAGING/doc/std"
 "$RELEASE_STAGING/bin/zig" test ../lib/std/std.zig \
-  -femit-docs=$RELEASE_STAGING/docs/std \
+  -femit-docs=$RELEASE_STAGING/doc/std \
   -fno-emit-bin \
   --zig-lib-dir "$(pwd)/../lib"
 
 cp ../LICENSE $RELEASE_STAGING/
-cp ../zig-cache/langref.html $RELEASE_STAGING/docs/
+cp ../zig-cache/langref.html $RELEASE_STAGING/doc/
 
 # Look for HTML errors.
-tidy --drop-empty-elements no -qe $RELEASE_STAGING/docs/langref.html
+tidy --drop-empty-elements no -qe $RELEASE_STAGING/doc/langref.html
 
 # Explicit exit helps show last command duration.
 exit
diff --git a/ci/zinc/macos_package b/ci/zinc/macos_package
index 6f866d098c..136dbc91fb 100755
--- a/ci/zinc/macos_package
+++ b/ci/zinc/macos_package
@@ -24,7 +24,7 @@ mv $INSTALL_PREFIX/lib/zig $INSTALL_PREFIX/lib2
 rmdir $INSTALL_PREFIX/lib
 mv $INSTALL_PREFIX/lib2 $INSTALL_PREFIX/lib
 
-cp -r "$ZIG_PREFIX/docs" "$INSTALL_PREFIX/"
+cp -r "$ZIG_PREFIX/doc" "$INSTALL_PREFIX/"
 cp "$ZIG_PREFIX/LICENSE" "$INSTALL_PREFIX/"
 
 mv "$INSTALL_PREFIX" "$BASENAME"

From d03c47bf85b17f7727d2f1fe5bd497b311c9eba7 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Wed, 26 Oct 2022 00:30:17 +0300
Subject: [PATCH 50/70] Sema: use `runtime_value` instead of creating allocs

---
 src/Sema.zig                 | 76 ++++++++++++++++++++----------------
 src/TypedValue.zig           |  2 +-
 src/arch/aarch64/CodeGen.zig |  6 ++-
 src/arch/arm/CodeGen.zig     |  6 ++-
 src/arch/wasm/CodeGen.zig    |  6 ++-
 src/arch/x86_64/CodeGen.zig  |  6 ++-
 src/codegen.zig              |  7 +++-
 src/codegen/c.zig            |  6 ++-
 src/codegen/llvm.zig         |  6 ++-
 src/value.zig                | 19 ++++-----
 test/behavior/bugs/13164.zig |  1 +
 test/behavior/vector.zig     | 37 ++++++++++++++++++
 12 files changed, 126 insertions(+), 52 deletions(-)

diff --git a/src/Sema.zig b/src/Sema.zig
index 4c2f72034e..931e06724b 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -1827,6 +1827,22 @@ fn resolveMaybeUndefValAllowVariables(
     block: *Block,
     src: LazySrcLoc,
     inst: Air.Inst.Ref,
+) CompileError!?Value {
+    var make_runtime = false;
+    if (try sema.resolveMaybeUndefValAllowVariablesMaybeRuntime(block, src, inst, &make_runtime)) |val| {
+        if (make_runtime) return null;
+        return val;
+    }
+    return null;
+}
+
+/// Returns all Value tags including `variable`, `undef` and `runtime_value`.
+fn resolveMaybeUndefValAllowVariablesMaybeRuntime(
+    sema: *Sema,
+    block: *Block,
+    src: LazySrcLoc,
+    inst: Air.Inst.Ref,
+    make_runtime: *bool,
 ) CompileError!?Value {
     // First section of indexes correspond to a set number of constant values.
     var i: usize = @enumToInt(inst);
@@ -1843,7 +1859,7 @@ fn resolveMaybeUndefValAllowVariables(
         .constant => {
             const ty_pl = sema.air_instructions.items(.data)[i].ty_pl;
             const val = sema.air_values.items[ty_pl.payload];
-            if (val.tag() == .runtime_int) return null;
+            if (val.tag() == .runtime_value) make_runtime.* = true;
             return val;
         },
         .const_ty => {
@@ -3896,6 +3912,7 @@ fn validateUnionInit(
     var first_block_index = block.instructions.items.len;
     var block_index = block.instructions.items.len - 1;
     var init_val: ?Value = null;
+    var make_runtime = false;
     while (block_index > 0) : (block_index -= 1) {
         const store_inst = block.instructions.items[block_index];
         if (store_inst == field_ptr_air_inst) break;
@@ -3920,7 +3937,7 @@ fn validateUnionInit(
         } else {
             first_block_index = @min(first_block_index, block_index);
         }
-        init_val = try sema.resolveMaybeUndefValAllowVariables(block, init_src, bin_op.rhs);
+        init_val = try sema.resolveMaybeUndefValAllowVariablesMaybeRuntime(block, init_src, bin_op.rhs, &make_runtime);
         break;
     }
 
@@ -3933,10 +3950,11 @@ fn validateUnionInit(
         // instead a single `store` to the result ptr with a comptime union value.
         block.instructions.shrinkRetainingCapacity(first_block_index);
 
-        const union_val = try Value.Tag.@"union".create(sema.arena, .{
+        var union_val = try Value.Tag.@"union".create(sema.arena, .{
             .tag = tag_val,
             .val = val,
         });
+        if (make_runtime) union_val = try Value.Tag.runtime_value.create(sema.arena, union_val);
         const union_init = try sema.addConstant(union_ty, union_val);
         try sema.storePtr2(block, init_src, union_ptr, init_src, union_init, init_src, .store);
         return;
@@ -4054,6 +4072,7 @@ fn validateStructInit(
 
     var struct_is_comptime = true;
     var first_block_index = block.instructions.items.len;
+    var make_runtime = false;
 
     const air_tags = sema.air_instructions.items(.tag);
     const air_datas = sema.air_instructions.items(.data);
@@ -4130,7 +4149,7 @@ fn validateStructInit(
                 } else {
                     first_block_index = @min(first_block_index, block_index);
                 }
-                if (try sema.resolveMaybeUndefValAllowVariables(block, field_src, bin_op.rhs)) |val| {
+                if (try sema.resolveMaybeUndefValAllowVariablesMaybeRuntime(block, field_src, bin_op.rhs, &make_runtime)) |val| {
                     field_values[i] = val;
                 } else {
                     struct_is_comptime = false;
@@ -4185,7 +4204,8 @@ fn validateStructInit(
         // instead a single `store` to the struct_ptr with a comptime struct value.
 
         block.instructions.shrinkRetainingCapacity(first_block_index);
-        const struct_val = try Value.Tag.aggregate.create(sema.arena, field_values);
+        var struct_val = try Value.Tag.aggregate.create(sema.arena, field_values);
+        if (make_runtime) struct_val = try Value.Tag.runtime_value.create(sema.arena, struct_val);
         const struct_init = try sema.addConstant(struct_ty, struct_val);
         try sema.storePtr2(block, init_src, struct_ptr, init_src, struct_init, init_src, .store);
         return;
@@ -4265,6 +4285,7 @@ fn zirValidateArrayInit(
 
     var array_is_comptime = true;
     var first_block_index = block.instructions.items.len;
+    var make_runtime = false;
 
     // Collect the comptime element values in case the array literal ends up
     // being comptime-known.
@@ -4326,7 +4347,7 @@ fn zirValidateArrayInit(
                     array_is_comptime = false;
                     continue;
                 }
-                if (try sema.resolveMaybeUndefValAllowVariables(block, elem_src, bin_op.rhs)) |val| {
+                if (try sema.resolveMaybeUndefValAllowVariablesMaybeRuntime(block, elem_src, bin_op.rhs, &make_runtime)) |val| {
                     element_vals[i] = val;
                 } else {
                     array_is_comptime = false;
@@ -4352,7 +4373,7 @@ fn zirValidateArrayInit(
                     array_is_comptime = false;
                     continue;
                 }
-                if (try sema.resolveMaybeUndefValAllowVariables(block, elem_src, bin_op.rhs)) |val| {
+                if (try sema.resolveMaybeUndefValAllowVariablesMaybeRuntime(block, elem_src, bin_op.rhs, &make_runtime)) |val| {
                     element_vals[i] = val;
                 } else {
                     array_is_comptime = false;
@@ -4383,7 +4404,8 @@ fn zirValidateArrayInit(
 
         block.instructions.shrinkRetainingCapacity(first_block_index);
 
-        const array_val = try Value.Tag.aggregate.create(sema.arena, element_vals);
+        var array_val = try Value.Tag.aggregate.create(sema.arena, element_vals);
+        if (make_runtime) array_val = try Value.Tag.runtime_value.create(sema.arena, array_val);
         const array_init = try sema.addConstant(array_ty, array_val);
         try sema.storePtr2(block, init_src, array_ptr, init_src, array_init, init_src, .store);
     }
@@ -6635,20 +6657,14 @@ fn analyzeInlineCallArg(
                     .ty = param_ty,
                     .val = arg_val,
                 };
-            } else if (((try sema.resolveMaybeUndefVal(arg_block, arg_src, casted_arg)) == null) or
-                try sema.typeRequiresComptime(param_ty) or zir_tags[inst] == .param_comptime)
-            {
+            } else if (zir_tags[inst] == .param_comptime or try sema.typeRequiresComptime(param_ty)) {
                 try sema.inst_map.putNoClobber(sema.gpa, inst, casted_arg);
-            } else {
+            } else if (try sema.resolveMaybeUndefVal(arg_block, arg_src, casted_arg)) |val| {
                 // We have a comptime value but we need a runtime value to preserve inlining semantics,
-                const ptr_type = try Type.ptr(sema.arena, sema.mod, .{
-                    .pointee_type = param_ty,
-                    .@"addrspace" = target_util.defaultAddressSpace(sema.mod.getTarget(), .local),
-                });
-                const alloc = try arg_block.addTy(.alloc, ptr_type);
-                _ = try arg_block.addBinOp(.store, alloc, casted_arg);
-                const loaded = try arg_block.addTyOp(.load, param_ty, alloc);
-                try sema.inst_map.putNoClobber(sema.gpa, inst, loaded);
+                const wrapped = try sema.addConstant(param_ty, try Value.Tag.runtime_value.create(sema.arena, val));
+                try sema.inst_map.putNoClobber(sema.gpa, inst, wrapped);
+            } else {
+                try sema.inst_map.putNoClobber(sema.gpa, inst, casted_arg);
             }
 
             arg_i.* += 1;
@@ -6685,20 +6701,14 @@ fn analyzeInlineCallArg(
                     .ty = sema.typeOf(uncasted_arg),
                     .val = arg_val,
                 };
-            } else if ((try sema.resolveMaybeUndefVal(arg_block, arg_src, uncasted_arg)) == null or
-                try sema.typeRequiresComptime(param_ty) or zir_tags[inst] == .param_anytype_comptime)
-            {
+            } else if (zir_tags[inst] == .param_anytype_comptime or try sema.typeRequiresComptime(param_ty)) {
                 try sema.inst_map.putNoClobber(sema.gpa, inst, uncasted_arg);
-            } else {
+            } else if (try sema.resolveMaybeUndefVal(arg_block, arg_src, uncasted_arg)) |val| {
                 // We have a comptime value but we need a runtime value to preserve inlining semantics,
-                const ptr_type = try Type.ptr(sema.arena, sema.mod, .{
-                    .pointee_type = param_ty,
-                    .@"addrspace" = target_util.defaultAddressSpace(sema.mod.getTarget(), .local),
-                });
-                const alloc = try arg_block.addTy(.alloc, ptr_type);
-                _ = try arg_block.addBinOp(.store, alloc, uncasted_arg);
-                const loaded = try arg_block.addTyOp(.load, param_ty, alloc);
-                try sema.inst_map.putNoClobber(sema.gpa, inst, loaded);
+                const wrapped = try sema.addConstant(param_ty, try Value.Tag.runtime_value.create(sema.arena, val));
+                try sema.inst_map.putNoClobber(sema.gpa, inst, wrapped);
+            } else {
+                try sema.inst_map.putNoClobber(sema.gpa, inst, uncasted_arg);
             }
 
             arg_i.* += 1;
@@ -14826,7 +14836,7 @@ fn zirBuiltinSrc(
     // fn_name: [:0]const u8,
     field_values[1] = func_name_val;
     // line: u32
-    field_values[2] = try Value.Tag.runtime_int.create(sema.arena, extra.line + 1);
+    field_values[2] = try Value.Tag.runtime_value.create(sema.arena, try Value.Tag.int_u64.create(sema.arena, extra.line + 1));
     // column: u32,
     field_values[3] = try Value.Tag.int_u64.create(sema.arena, extra.column + 1);
 
diff --git a/src/TypedValue.zig b/src/TypedValue.zig
index ba32e55f1e..619fb003f9 100644
--- a/src/TypedValue.zig
+++ b/src/TypedValue.zig
@@ -477,6 +477,6 @@ pub fn print(
         },
         .generic_poison_type => return writer.writeAll("(generic poison type)"),
         .generic_poison => return writer.writeAll("(generic poison)"),
-        .runtime_int => return writer.writeAll("[runtime value]"),
+        .runtime_value => return writer.writeAll("[runtime value]"),
     };
 }
diff --git a/src/arch/aarch64/CodeGen.zig b/src/arch/aarch64/CodeGen.zig
index eb8ca8e8f1..3bb5bbe0d3 100644
--- a/src/arch/aarch64/CodeGen.zig
+++ b/src/arch/aarch64/CodeGen.zig
@@ -5401,7 +5401,11 @@ fn lowerUnnamedConst(self: *Self, tv: TypedValue) InnerError!MCValue {
     }
 }
 
-fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {
+fn genTypedValue(self: *Self, arg_tv: TypedValue) InnerError!MCValue {
+    var typed_value = arg_tv;
+    if (typed_value.val.castTag(.runtime_value)) |rt| {
+        typed_value.val = rt.data;
+    }
     log.debug("genTypedValue: ty = {}, val = {}", .{ typed_value.ty.fmtDebug(), typed_value.val.fmtDebug() });
     if (typed_value.val.isUndef())
         return MCValue{ .undef = {} };
diff --git a/src/arch/arm/CodeGen.zig b/src/arch/arm/CodeGen.zig
index 1ebc348fc2..67cf899dc3 100644
--- a/src/arch/arm/CodeGen.zig
+++ b/src/arch/arm/CodeGen.zig
@@ -6047,7 +6047,11 @@ fn lowerUnnamedConst(self: *Self, tv: TypedValue) InnerError!MCValue {
     }
 }
 
-fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {
+fn genTypedValue(self: *Self, arg_tv: TypedValue) InnerError!MCValue {
+    var typed_value = arg_tv;
+    if (typed_value.val.castTag(.runtime_value)) |rt| {
+        typed_value.val = rt.data;
+    }
     log.debug("genTypedValue: ty = {}, val = {}", .{ typed_value.ty.fmtDebug(), typed_value.val.fmtDebug() });
     if (typed_value.val.isUndef())
         return MCValue{ .undef = {} };
diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index 538fcb13c1..69d5e38f65 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -2582,7 +2582,11 @@ fn toTwosComplement(value: anytype, bits: u7) std.meta.Int(.unsigned, @typeInfo(
     return @intCast(WantedT, result);
 }
 
-fn lowerConstant(func: *CodeGen, val: Value, ty: Type) InnerError!WValue {
+fn lowerConstant(func: *CodeGen, arg_val: Value, ty: Type) InnerError!WValue {
+    var val = arg_val;
+    if (val.castTag(.runtime_value)) |rt| {
+        val = rt.data;
+    }
     if (val.isUndefDeep()) return func.emitUndefined(ty);
     if (val.castTag(.decl_ref)) |decl_ref| {
         const decl_index = decl_ref.data;
diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig
index 5f793aaeb9..965a34251c 100644
--- a/src/arch/x86_64/CodeGen.zig
+++ b/src/arch/x86_64/CodeGen.zig
@@ -6960,7 +6960,11 @@ fn lowerUnnamedConst(self: *Self, tv: TypedValue) InnerError!MCValue {
     }
 }
 
-fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {
+fn genTypedValue(self: *Self, arg_tv: TypedValue) InnerError!MCValue {
+    var typed_value = arg_tv;
+    if (typed_value.val.castTag(.runtime_value)) |rt| {
+        typed_value.val = rt.data;
+    }
     log.debug("genTypedValue: ty = {}, val = {}", .{ typed_value.ty.fmtDebug(), typed_value.val.fmtDebug() });
     if (typed_value.val.isUndef())
         return MCValue{ .undef = {} };
diff --git a/src/codegen.zig b/src/codegen.zig
index e7f927a2d6..757bd23b38 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -149,7 +149,7 @@ fn writeFloat(comptime F: type, f: F, target: Target, endian: std.builtin.Endian
 pub fn generateSymbol(
     bin_file: *link.File,
     src_loc: Module.SrcLoc,
-    typed_value: TypedValue,
+    arg_tv: TypedValue,
     code: *std.ArrayList(u8),
     debug_output: DebugInfoOutput,
     reloc_info: RelocInfo,
@@ -157,6 +157,11 @@ pub fn generateSymbol(
     const tracy = trace(@src());
     defer tracy.end();
 
+    var typed_value = arg_tv;
+    if (arg_tv.val.castTag(.runtime_value)) |rt| {
+        typed_value.val = rt.data;
+    }
+
     const target = bin_file.options.target;
     const endian = target.cpu.arch.endian();
 
diff --git a/src/codegen/c.zig b/src/codegen/c.zig
index d6584d75ae..d0f76f0390 100644
--- a/src/codegen/c.zig
+++ b/src/codegen/c.zig
@@ -555,9 +555,13 @@ pub const DeclGen = struct {
         dg: *DeclGen,
         writer: anytype,
         ty: Type,
-        val: Value,
+        arg_val: Value,
         location: ValueRenderLocation,
     ) error{ OutOfMemory, AnalysisFail }!void {
+        var val = arg_val;
+        if (val.castTag(.runtime_value)) |rt| {
+            val = rt.data;
+        }
         const target = dg.module.getTarget();
         if (val.isUndefDeep()) {
             switch (ty.zigTypeTag()) {
diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig
index ffc19cb6f6..938770629f 100644
--- a/src/codegen/llvm.zig
+++ b/src/codegen/llvm.zig
@@ -3187,7 +3187,11 @@ pub const DeclGen = struct {
         return llvm_elem_ty;
     }
 
-    fn lowerValue(dg: *DeclGen, tv: TypedValue) Error!*llvm.Value {
+    fn lowerValue(dg: *DeclGen, arg_tv: TypedValue) Error!*llvm.Value {
+        var tv = arg_tv;
+        if (tv.val.castTag(.runtime_value)) |rt| {
+            tv.val = rt.data;
+        }
         if (tv.val.isUndef()) {
             const llvm_type = try dg.lowerType(tv.ty);
             return llvm_type.getUndef();
diff --git a/src/value.zig b/src/value.zig
index d24c5a1c17..28601c1723 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -111,10 +111,12 @@ pub const Value = extern union {
         int_i64,
         int_big_positive,
         int_big_negative,
-        runtime_int,
         function,
         extern_fn,
         variable,
+        /// A wrapper for values which are comptime-known but should
+        /// semantically be runtime-known.
+        runtime_value,
         /// Represents a pointer to a Decl.
         /// When machine codegen backend sees this, it must set the Decl's `alive` field to true.
         decl_ref,
@@ -282,6 +284,7 @@ pub const Value = extern union {
                 .eu_payload,
                 .opt_payload,
                 .empty_array_sentinel,
+                .runtime_value,
                 => Payload.SubValue,
 
                 .eu_payload_ptr,
@@ -305,7 +308,6 @@ pub const Value = extern union {
                 .int_type => Payload.IntType,
                 .int_u64 => Payload.U64,
                 .int_i64 => Payload.I64,
-                .runtime_int => Payload.U64,
                 .function => Payload.Function,
                 .variable => Payload.Variable,
                 .decl_ref_mut => Payload.DeclRefMut,
@@ -485,7 +487,6 @@ pub const Value = extern union {
             },
             .int_type => return self.copyPayloadShallow(arena, Payload.IntType),
             .int_u64 => return self.copyPayloadShallow(arena, Payload.U64),
-            .runtime_int => return self.copyPayloadShallow(arena, Payload.U64),
             .int_i64 => return self.copyPayloadShallow(arena, Payload.I64),
             .int_big_positive, .int_big_negative => {
                 const old_payload = self.cast(Payload.BigInt).?;
@@ -567,6 +568,7 @@ pub const Value = extern union {
             .eu_payload,
             .opt_payload,
             .empty_array_sentinel,
+            .runtime_value,
             => {
                 const payload = self.cast(Payload.SubValue).?;
                 const new_payload = try arena.create(Payload.SubValue);
@@ -765,7 +767,7 @@ pub const Value = extern union {
             .int_i64 => return std.fmt.formatIntValue(val.castTag(.int_i64).?.data, "", options, out_stream),
             .int_big_positive => return out_stream.print("{}", .{val.castTag(.int_big_positive).?.asBigInt()}),
             .int_big_negative => return out_stream.print("{}", .{val.castTag(.int_big_negative).?.asBigInt()}),
-            .runtime_int => return out_stream.writeAll("[runtime value]"),
+            .runtime_value => return out_stream.writeAll("[runtime value]"),
             .function => return out_stream.print("(function decl={d})", .{val.castTag(.function).?.data.owner_decl}),
             .extern_fn => return out_stream.writeAll("(extern function)"),
             .variable => return out_stream.writeAll("(variable)"),
@@ -1081,8 +1083,6 @@ pub const Value = extern union {
             .int_big_positive => return val.castTag(.int_big_positive).?.asBigInt(),
             .int_big_negative => return val.castTag(.int_big_negative).?.asBigInt(),
 
-            .runtime_int => return BigIntMutable.init(&space.limbs, val.castTag(.runtime_int).?.data).toConst(),
-
             .undef => unreachable,
 
             .lazy_align => {
@@ -1138,8 +1138,6 @@ pub const Value = extern union {
             .int_big_positive => return val.castTag(.int_big_positive).?.asBigInt().to(u64) catch null,
             .int_big_negative => return val.castTag(.int_big_negative).?.asBigInt().to(u64) catch null,
 
-            .runtime_int => return val.castTag(.runtime_int).?.data,
-
             .undef => unreachable,
 
             .lazy_align => {
@@ -2357,6 +2355,8 @@ pub const Value = extern union {
         const zig_ty_tag = ty.zigTypeTag();
         std.hash.autoHash(hasher, zig_ty_tag);
         if (val.isUndef()) return;
+        // The value is runtime-known and shouldn't affect the hash.
+        if (val.tag() == .runtime_value) return;
 
         switch (zig_ty_tag) {
             .BoundFn => unreachable, // TODO remove this from the language
@@ -2632,9 +2632,6 @@ pub const Value = extern union {
             .lazy_size,
             => return hashInt(ptr_val, hasher, target),
 
-            // The value is runtime-known and shouldn't affect the hash.
-            .runtime_int => {},
-
             else => unreachable,
         }
     }
diff --git a/test/behavior/bugs/13164.zig b/test/behavior/bugs/13164.zig
index ee9fe1c120..37f5bdf805 100644
--- a/test/behavior/bugs/13164.zig
+++ b/test/behavior/bugs/13164.zig
@@ -10,6 +10,7 @@ inline fn setLimits(min: ?u32, max: ?u32) !void {
 test {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
 
     var x: u32 = 42;
     try setLimits(x, null);
diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig
index 80fa2021d8..22e12d0808 100644
--- a/test/behavior/vector.zig
+++ b/test/behavior/vector.zig
@@ -1135,3 +1135,40 @@ test "array of vectors is copied" {
     points2[0..points.len].* = points;
     try std.testing.expectEqual(points2[6], Vec3{ -345, -311, 381 });
 }
+
+test "byte vector initialized in inline function" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+
+    const S = struct {
+        inline fn boolx4(e0: bool, e1: bool, e2: bool, e3: bool) @Vector(4, bool) {
+            return .{ e0, e1, e2, e3 };
+        }
+
+        fn all(vb: @Vector(4, bool)) bool {
+            return @reduce(.And, vb);
+        }
+    };
+
+    try expect(S.all(S.boolx4(true, true, true, true)));
+}
+
+test "byte vector initialized in inline function" {
+    // TODO https://github.com/ziglang/zig/issues/13279
+    if (true) return error.SkipZigTest;
+
+    const S = struct {
+        fn boolx4(e0: bool, e1: bool, e2: bool, e3: bool) @Vector(4, bool) {
+            return .{ e0, e1, e2, e3 };
+        }
+
+        fn all(vb: @Vector(4, bool)) bool {
+            return @reduce(.And, vb);
+        }
+    };
+
+    try expect(S.all(S.boolx4(true, true, true, true)));
+}

From bc72ae5e4e6d8f2253aed1316b053ad1022f9f67 Mon Sep 17 00:00:00 2001
From: InKryption <inkryption07@gmail.com>
Date: Fri, 16 Sep 2022 18:34:51 +0200
Subject: [PATCH 51/70] Sema: Prevent coercion from tuple pointer to mutable
 slice.

Also fix some stdlib code affected by this.

Co-authored by: topolarity <topolarity@tapscott.me>
---
 lib/std/fs/wasi.zig                           |  2 +-
 lib/std/x/net/bpf.zig                         |  4 +-
 src/Sema.zig                                  | 63 +++++++++++--------
 test/behavior/packed-struct.zig               |  2 +-
 .../stage2/tuple_ptr_to_mut_slice.zig         | 32 ++++++++++
 5 files changed, 72 insertions(+), 31 deletions(-)
 create mode 100644 test/cases/compile_errors/stage2/tuple_ptr_to_mut_slice.zig

diff --git a/lib/std/fs/wasi.zig b/lib/std/fs/wasi.zig
index 81a43062dc..522731ef02 100644
--- a/lib/std/fs/wasi.zig
+++ b/lib/std/fs/wasi.zig
@@ -201,7 +201,7 @@ pub const PreopenList = struct {
             // If we were provided a CWD root to resolve against, we try to treat Preopen dirs as
             // POSIX paths, relative to "/" or `cwd_root` depending on whether they start with "."
             const path = if (cwd_root) |cwd| blk: {
-                const resolve_paths: [][]const u8 = if (raw_path[0] == '.') &.{ cwd, raw_path } else &.{ "/", raw_path };
+                const resolve_paths: []const []const u8 = if (raw_path[0] == '.') &.{ cwd, raw_path } else &.{ "/", raw_path };
                 break :blk fs.path.resolve(self.buffer.allocator, resolve_paths) catch |err| switch (err) {
                     error.CurrentWorkingDirectoryUnlinked => unreachable, // root is absolute, so CWD not queried
                     else => |e| return e,
diff --git a/lib/std/x/net/bpf.zig b/lib/std/x/net/bpf.zig
index e8db9a3e0e..8fd318b03b 100644
--- a/lib/std/x/net/bpf.zig
+++ b/lib/std/x/net/bpf.zig
@@ -691,14 +691,14 @@ test "tcpdump filter" {
     );
 }
 
-fn expectPass(data: anytype, filter: []Insn) !void {
+fn expectPass(data: anytype, filter: []const Insn) !void {
     try expectEqual(
         @as(u32, 0),
         try simulate(mem.asBytes(data), filter, .Big),
     );
 }
 
-fn expectFail(expected_error: anyerror, data: anytype, filter: []Insn) !void {
+fn expectFail(expected_error: anyerror, data: anytype, filter: []const Insn) !void {
     try expectError(
         expected_error,
         simulate(mem.asBytes(data), filter, native_endian),
diff --git a/src/Sema.zig b/src/Sema.zig
index 931e06724b..608d6d986a 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -18208,7 +18208,7 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
             return sema.analyzeDeclVal(block, src, new_decl_index);
         },
         .Fn => {
-            const struct_val = union_val.val.castTag(.aggregate).?.data;
+            const struct_val: []const Value = union_val.val.castTag(.aggregate).?.data;
             // TODO use reflection instead of magic numbers here
             // calling_convention: CallingConvention,
             const cc = struct_val[0].toEnum(std.builtin.CallingConvention);
@@ -18242,12 +18242,17 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
                     break :alignment alignment;
                 }
             };
+            const return_type = return_type_val.optionalValue() orelse
+                return sema.fail(block, src, "Type.Fn.return_type must be non-null for @Type", .{});
+
             var buf: Value.ToTypeBuffer = undefined;
 
             const args_slice_val = args_val.castTag(.slice).?.data;
             const args_len = try sema.usizeCast(block, src, args_slice_val.len.toUnsignedInt(mod.getTarget()));
-            var param_types = try sema.arena.alloc(Type, args_len);
-            var comptime_params = try sema.arena.alloc(bool, args_len);
+
+            const param_types = try sema.arena.alloc(Type, args_len);
+            const comptime_params = try sema.arena.alloc(bool, args_len);
+
             var noalias_bits: u32 = 0;
             var i: usize = 0;
             while (i < args_len) : (i += 1) {
@@ -18275,11 +18280,9 @@ fn zirReify(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData, in
                     return sema.fail(block, src, "Type.Fn.Param.arg_type must be non-null for @Type", .{});
 
                 param_types[i] = try param_type.toType(&buf).copy(sema.arena);
+                comptime_params[i] = false;
             }
 
-            const return_type = return_type_val.optionalValue() orelse
-                return sema.fail(block, src, "Type.Fn.return_type must be non-null for @Type", .{});
-
             var fn_info = Type.Payload.Function.Data{
                 .param_types = param_types,
                 .comptime_params = comptime_params.ptr,
@@ -24075,27 +24078,7 @@ fn coerceExtra(
                     },
                     else => {},
                 },
-                .Slice => {
-                    // pointer to tuple to slice
-                    if (inst_ty.isSinglePointer() and inst_ty.childType().isTuple() and dest_info.size == .Slice and
-                        sema.checkPtrAttributes(dest_ty, inst_ty, &in_memory_result))
-                    {
-                        return sema.coerceTupleToSlicePtrs(block, dest_ty, dest_ty_src, inst, inst_src);
-                    }
-
-                    // empty tuple to zero-length slice
-                    // note that this allows coercing to a mutable slice.
-                    if (inst_ty.isSinglePointer() and
-                        inst_ty.childType().tag() == .empty_struct_literal and
-                        dest_info.size == .Slice)
-                    {
-                        const slice_val = try Value.Tag.slice.create(sema.arena, .{
-                            .ptr = Value.undef,
-                            .len = Value.zero,
-                        });
-                        return sema.addConstant(dest_ty, slice_val);
-                    }
-
+                .Slice => to_slice: {
                     if (inst_ty.zigTypeTag() == .Array) {
                         return sema.fail(
                             block,
@@ -24104,6 +24087,32 @@ fn coerceExtra(
                             .{dest_ty.fmt(sema.mod)},
                         );
                     }
+
+                    if (!inst_ty.isSinglePointer()) break :to_slice;
+                    const inst_child_ty = inst_ty.childType();
+                    if (!inst_child_ty.isTuple()) break :to_slice;
+
+                    // empty tuple to zero-length slice
+                    // note that this allows coercing to a mutable slice.
+                    if (inst_child_ty.tupleFields().types.len == 0) {
+                        const slice_val = try Value.Tag.slice.create(sema.arena, .{
+                            .ptr = Value.undef,
+                            .len = Value.zero,
+                        });
+                        return sema.addConstant(dest_ty, slice_val);
+                    }
+
+                    // pointer to tuple to slice
+                    if (dest_info.mutable) {
+                        const err_msg = err_msg: {
+                            const err_msg = try sema.errMsg(block, inst_src, "cannot cast pointer to tuple to '{}'", .{dest_ty.fmt(sema.mod)});
+                            errdefer err_msg.deinit(sema.gpa);
+                            try sema.errNote(block, dest_ty_src, err_msg, "pointers to tuples can only coerce to constant pointers", .{});
+                            break :err_msg err_msg;
+                        };
+                        return sema.failWithOwnedErrorMsg(err_msg);
+                    }
+                    return sema.coerceTupleToSlicePtrs(block, dest_ty, dest_ty_src, inst, inst_src);
                 },
                 .Many => p: {
                     if (!inst_ty.isSlice()) break :p;
diff --git a/test/behavior/packed-struct.zig b/test/behavior/packed-struct.zig
index 5a878112b5..b3ed2af536 100644
--- a/test/behavior/packed-struct.zig
+++ b/test/behavior/packed-struct.zig
@@ -410,7 +410,7 @@ test "load pointer from packed struct" {
         y: u32,
     };
     var a: A = .{ .index = 123 };
-    var b_list: []B = &.{.{ .x = &a, .y = 99 }};
+    var b_list: []const B = &.{.{ .x = &a, .y = 99 }};
     for (b_list) |b| {
         var i = b.x.index;
         try expect(i == 123);
diff --git a/test/cases/compile_errors/stage2/tuple_ptr_to_mut_slice.zig b/test/cases/compile_errors/stage2/tuple_ptr_to_mut_slice.zig
new file mode 100644
index 0000000000..24e4753563
--- /dev/null
+++ b/test/cases/compile_errors/stage2/tuple_ptr_to_mut_slice.zig
@@ -0,0 +1,32 @@
+export fn entry1() void {
+    var a = .{ 1, 2, 3 };
+    _ = @as([]u8, &a);
+}
+export fn entry2() void {
+    var a = .{ @as(u8, 1), @as(u8, 2), @as(u8, 3) };
+    _ = @as([]u8, &a);
+}
+
+// runtime values
+var vals = [_]u7{ 4, 5, 6 };
+export fn entry3() void {
+    var a = .{ vals[0], vals[1], vals[2] };
+    _ = @as([]u8, &a);
+}
+export fn entry4() void {
+    var a = .{ @as(u8, vals[0]), @as(u8, vals[1]), @as(u8, vals[2]) };
+    _ = @as([]u8, &a);
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :3:19: error: cannot cast pointer to tuple to '[]u8'
+// :3:19: note: pointers to tuples can only coerce to constant pointers
+// :7:19: error: cannot cast pointer to tuple to '[]u8'
+// :7:19: note: pointers to tuples can only coerce to constant pointers
+// :14:19: error: cannot cast pointer to tuple to '[]u8'
+// :14:19: note: pointers to tuples can only coerce to constant pointers
+// :18:19: error: cannot cast pointer to tuple to '[]u8'
+// :18:19: note: pointers to tuples can only coerce to constant pointers

From 1f4f8d34a1e607a1189280cc0f809c851431a520 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 27 Oct 2022 13:37:46 -0700
Subject: [PATCH 52/70] compiler_rt: fix memcmp wrong for some inputs

See the new test case - this fails in the previous implementation.

See #13303
---
 lib/compiler_rt/memcmp.zig | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/lib/compiler_rt/memcmp.zig b/lib/compiler_rt/memcmp.zig
index b0a925438f..6f7e48135b 100644
--- a/lib/compiler_rt/memcmp.zig
+++ b/lib/compiler_rt/memcmp.zig
@@ -5,27 +5,26 @@ comptime {
     @export(memcmp, .{ .name = "memcmp", .linkage = common.linkage });
 }
 
-pub fn memcmp(vl: ?[*]const u8, vr: ?[*]const u8, n: usize) callconv(.C) c_int {
-    @setRuntimeSafety(false);
-
-    var index: usize = 0;
-    while (index != n) : (index += 1) {
-        const compare_val = @bitCast(i8, vl.?[index] -% vr.?[index]);
-        if (compare_val != 0) {
-            return compare_val;
-        }
+pub fn memcmp(vl: [*]const u8, vr: [*]const u8, n: usize) callconv(.C) c_int {
+    var i: usize = 0;
+    while (i < n) : (i += 1) {
+        const compared = @as(c_int, vl[i]) -% @as(c_int, vr[i]);
+        if (compared != 0) return compared;
     }
-
     return 0;
 }
 
 test "memcmp" {
-    const base_arr = &[_]u8{ 1, 1, 1 };
+    const arr0 = &[_]u8{ 1, 1, 1 };
     const arr1 = &[_]u8{ 1, 1, 1 };
     const arr2 = &[_]u8{ 1, 0, 1 };
     const arr3 = &[_]u8{ 1, 2, 1 };
+    const arr4 = &[_]u8{ 1, 0xff, 1 };
 
-    try std.testing.expect(memcmp(base_arr[0..], arr1[0..], base_arr.len) == 0);
-    try std.testing.expect(memcmp(base_arr[0..], arr2[0..], base_arr.len) > 0);
-    try std.testing.expect(memcmp(base_arr[0..], arr3[0..], base_arr.len) < 0);
+    try std.testing.expect(memcmp(arr0, arr1, 3) == 0);
+    try std.testing.expect(memcmp(arr0, arr2, 3) > 0);
+    try std.testing.expect(memcmp(arr0, arr3, 3) < 0);
+
+    try std.testing.expect(memcmp(arr0, arr4, 3) < 0);
+    try std.testing.expect(memcmp(arr4, arr0, 3) > 0);
 }

From 23878aec4ab2120b74a18a110eb1d3d497e125af Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Thu, 27 Oct 2022 20:57:21 -0700
Subject: [PATCH 53/70] CI: azure: fix upload script

Partial revert of changes made in
398a3aae40bc03f6b7c6cd86d78a4cde125f2811, fixes regression.
---
 ci/azure/pipelines.yml | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/ci/azure/pipelines.yml b/ci/azure/pipelines.yml
index f9ab3dff2b..b0fbf0fb72 100644
--- a/ci/azure/pipelines.yml
+++ b/ci/azure/pipelines.yml
@@ -93,7 +93,6 @@ jobs:
       secureFile: aws_credentials
 
   - pwsh: |
-      Set-Variable -Name ZIGINSTALLDIR -Value "$(Get-Location)\stage3-release"
       $Env:AWS_SHARED_CREDENTIALS_FILE = "$Env:DOWNLOADSECUREFILE_SECUREFILEPATH"
 
       # Workaround Azure networking issue
@@ -101,15 +100,15 @@ jobs:
       $Env:AWS_EC2_METADATA_DISABLED = "true"
       $Env:AWS_REGION = "us-west-2"
 
-      mv LICENSE "$ZIGINSTALLDIR"
-      mv zig-cache/langref.html "$ZIGINSTALLDIR"
-      mv "$ZIGINSTALLDIR\bin\zig.exe" "$ZIGINSTALLDIR\doc\"
-      rmdir "$ZIGINSTALLDIR/bin"
+      mv LICENSE stage3-release/
+      mv zig-cache/langref.html stage3-release/
+      mv stage3-release/bin/zig.exe stage3-release/
+      rmdir stage3-release/bin
 
-      # Remove the unnecessary zig dir in $ZIGINSTALLDIR\lib\zig\std\std.zig
-      mv "$ZIGINSTALLDIR\lib\zig" "$ZIGINSTALLDIR\lib2"
-      rmdir "$ZIGINSTALLDIR\lib"
-      mv "$ZIGINSTALLDIR\lib2" "$ZIGINSTALLDIR\lib"
+      # Remove the unnecessary zig dir in $prefix/lib/zig/std/std.zig
+      mv stage3-release/lib/zig stage3-release/lib2
+      rmdir stage3-release/lib
+      mv stage3-release/lib2 stage3-release/lib
 
       Set-Variable -Name VERSION -Value $(./stage3-release/zig.exe version)
       Set-Variable -Name DIRNAME -Value "zig-windows-x86_64-$VERSION"

From c3b85e4e2f3da02d78ccb814e3025ee4b78d541b Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Thu, 27 Oct 2022 19:31:45 +0300
Subject: [PATCH 54/70] Sema: further enhance explanation of why expr is
 evaluated at comptime

---
 src/Sema.zig                                  | 185 +++++++++++-------
 .../condition_comptime_reason_explained.zig   |  48 +++++
 .../explain_why_fn_is_called_at_comptime.zig  |   2 +-
 ...n_why_generic_fn_is_called_at_comptime.zig |   2 +-
 ...unable_to_evaluate_expr_inside_cimport.zig |  15 ++
 test/compile_errors.zig                       |   2 +-
 6 files changed, 181 insertions(+), 73 deletions(-)
 create mode 100644 test/cases/compile_errors/condition_comptime_reason_explained.zig
 create mode 100644 test/cases/compile_errors/unable_to_evaluate_expr_inside_cimport.zig

diff --git a/src/Sema.zig b/src/Sema.zig
index 9f425b7bcf..d31c0745ed 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -151,6 +151,8 @@ pub const Block = struct {
     runtime_index: Value.RuntimeIndex = .zero,
     inline_block: Zir.Inst.Index = 0,
 
+    comptime_reason: ?*const ComptimeReason = null,
+    // TODO is_comptime and comptime_reason should probably be merged together.
     is_comptime: bool,
     is_typeof: bool = false,
     is_coerce_result_ptr: bool = false,
@@ -173,6 +175,49 @@ pub const Block = struct {
     /// Value for switch_capture in an inline case
     inline_case_capture: Air.Inst.Ref = .none,
 
+    const ComptimeReason = union(enum) {
+        c_import: struct {
+            block: *Block,
+            src: LazySrcLoc,
+        },
+        comptime_ret_ty: struct {
+            block: *Block,
+            func: Air.Inst.Ref,
+            func_src: LazySrcLoc,
+            return_ty: Type,
+        },
+
+        fn explain(cr: ComptimeReason, sema: *Sema, msg: ?*Module.ErrorMsg) !void {
+            const parent = msg orelse return;
+            const prefix = "expression is evaluated at comptime because ";
+            switch (cr) {
+                .c_import => |ci| {
+                    try sema.errNote(ci.block, ci.src, parent, prefix ++ "it is inside a @cImport", .{});
+                },
+                .comptime_ret_ty => |rt| {
+                    const src_loc = if (try sema.funcDeclSrc(rt.block, rt.func_src, rt.func)) |capture| blk: {
+                        var src_loc = capture;
+                        src_loc.lazy = .{ .node_offset_fn_type_ret_ty = 0 };
+                        break :blk src_loc;
+                    } else blk: {
+                        const src_decl = sema.mod.declPtr(rt.block.src_decl);
+                        break :blk rt.func_src.toSrcLoc(src_decl);
+                    };
+                    if (rt.return_ty.tag() == .generic_poison) {
+                        return sema.mod.errNoteNonLazy(src_loc, parent, prefix ++ "the generic function was instantiated with a comptime-only return type", .{});
+                    }
+                    try sema.mod.errNoteNonLazy(
+                        src_loc,
+                        parent,
+                        prefix ++ "the function returns a comptime-only type '{}'",
+                        .{rt.return_ty.fmt(sema.mod)},
+                    );
+                    try sema.explainWhyTypeIsComptime(rt.block, rt.func_src, parent, src_loc, rt.return_ty);
+                },
+            }
+        }
+    };
+
     const Param = struct {
         /// `noreturn` means `anytype`.
         ty: Type,
@@ -224,6 +269,7 @@ pub const Block = struct {
             .label = null,
             .inlining = parent.inlining,
             .is_comptime = parent.is_comptime,
+            .comptime_reason = parent.comptime_reason,
             .is_typeof = parent.is_typeof,
             .runtime_cond = parent.runtime_cond,
             .runtime_loop = parent.runtime_loop,
@@ -1420,7 +1466,10 @@ fn analyzeBodyInner(
                 const extra = sema.code.extraData(Zir.Inst.CondBr, inst_data.payload_index);
                 const then_body = sema.code.extra[extra.end..][0..extra.data.then_body_len];
                 const else_body = sema.code.extra[extra.end + then_body.len ..][0..extra.data.else_body_len];
-                const cond = try sema.resolveInstConst(block, cond_src, extra.data.condition, "condition in comptime branch must be comptime-known");
+                const cond = sema.resolveInstConst(block, cond_src, extra.data.condition, "condition in comptime branch must be comptime-known") catch |err| {
+                    if (err == error.AnalysisFail and block.comptime_reason != null) try block.comptime_reason.?.explain(sema, sema.err);
+                    return err;
+                };
                 const inline_body = if (cond.val.toBool()) then_body else else_body;
 
                 try sema.maybeErrorUnwrapCondbr(block, inline_body, extra.data.condition, cond_src);
@@ -1438,7 +1487,10 @@ fn analyzeBodyInner(
                 const extra = sema.code.extraData(Zir.Inst.CondBr, inst_data.payload_index);
                 const then_body = sema.code.extra[extra.end..][0..extra.data.then_body_len];
                 const else_body = sema.code.extra[extra.end + then_body.len ..][0..extra.data.else_body_len];
-                const cond = try sema.resolveInstConst(block, cond_src, extra.data.condition, "condition in comptime branch must be comptime-known");
+                const cond = sema.resolveInstConst(block, cond_src, extra.data.condition, "condition in comptime branch must be comptime-known") catch |err| {
+                    if (err == error.AnalysisFail and block.comptime_reason != null) try block.comptime_reason.?.explain(sema, sema.err);
+                    return err;
+                };
                 const inline_body = if (cond.val.toBool()) then_body else else_body;
                 const old_runtime_index = block.runtime_index;
                 defer block.runtime_index = old_runtime_index;
@@ -1460,7 +1512,10 @@ fn analyzeBodyInner(
                 const err_union = try sema.resolveInst(extra.data.operand);
                 const is_non_err = try sema.analyzeIsNonErrComptimeOnly(block, operand_src, err_union);
                 assert(is_non_err != .none);
-                const is_non_err_tv = try sema.resolveInstConst(block, operand_src, is_non_err, "try operand inside comptime block must be comptime-known");
+                const is_non_err_tv = sema.resolveInstConst(block, operand_src, is_non_err, "try operand inside comptime block must be comptime-known") catch |err| {
+                    if (err == error.AnalysisFail and block.comptime_reason != null) try block.comptime_reason.?.explain(sema, sema.err);
+                    return err;
+                };
                 if (is_non_err_tv.val.toBool()) {
                     const err_union_ty = sema.typeOf(err_union);
                     break :blk try sema.analyzeErrUnionPayload(block, src, err_union_ty, err_union, operand_src, false);
@@ -1516,7 +1571,10 @@ fn analyzeBodyInner(
                 const err_union = try sema.analyzeLoad(block, src, operand, operand_src);
                 const is_non_err = try sema.analyzeIsNonErrComptimeOnly(block, operand_src, err_union);
                 assert(is_non_err != .none);
-                const is_non_err_tv = try sema.resolveInstConst(block, operand_src, is_non_err, "try operand inside comptime block must be comptime-known");
+                const is_non_err_tv = sema.resolveInstConst(block, operand_src, is_non_err, "try operand inside comptime block must be comptime-known") catch |err| {
+                    if (err == error.AnalysisFail and block.comptime_reason != null) try block.comptime_reason.?.explain(sema, sema.err);
+                    return err;
+                };
                 if (is_non_err_tv.val.toBool()) {
                     break :blk try sema.analyzeErrUnionPayloadPtr(block, src, operand, false, false);
                 }
@@ -1675,8 +1733,8 @@ pub fn setupErrorReturnTrace(sema: *Sema, block: *Block, last_arg_index: usize)
         return;
     }
 
+    assert(!block.is_comptime);
     var err_trace_block = block.makeSubBlock();
-    err_trace_block.is_comptime = false;
     defer err_trace_block.instructions.deinit(sema.gpa);
 
     const src: LazySrcLoc = .unneeded;
@@ -4944,6 +5002,10 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
     var c_import_buf = std.ArrayList(u8).init(sema.gpa);
     defer c_import_buf.deinit();
 
+    var comptime_reason = .{ .c_import = .{
+        .block = parent_block,
+        .src = src,
+    } };
     var child_block: Block = .{
         .parent = parent_block,
         .sema = sema,
@@ -4952,7 +5014,8 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
         .wip_capture_scope = parent_block.wip_capture_scope,
         .instructions = .{},
         .inlining = parent_block.inlining,
-        .is_comptime = parent_block.is_comptime,
+        .is_comptime = true,
+        .comptime_reason = &comptime_reason,
         .c_import_buf = &c_import_buf,
         .runtime_cond = parent_block.runtime_cond,
         .runtime_loop = parent_block.runtime_loop,
@@ -5053,6 +5116,7 @@ fn zirBlock(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileErro
         .label = &label,
         .inlining = parent_block.inlining,
         .is_comptime = parent_block.is_comptime,
+        .comptime_reason = parent_block.comptime_reason,
         .is_typeof = parent_block.is_typeof,
         .want_safety = parent_block.want_safety,
         .float_mode = parent_block.float_mode,
@@ -5926,6 +5990,7 @@ fn zirCall(
         defer block.is_comptime = parent_comptime;
         if (arg_index < fn_params_len and func_ty_info.comptime_params[arg_index]) {
             block.is_comptime = true;
+            // TODO set comptime_reason
         }
 
         const param_ty_inst = try sema.addType(param_ty);
@@ -6056,37 +6121,6 @@ const GenericCallAdapter = struct {
     }
 };
 
-fn addComptimeReturnTypeNote(
-    sema: *Sema,
-    block: *Block,
-    func: Air.Inst.Ref,
-    func_src: LazySrcLoc,
-    return_ty: Type,
-    parent: *Module.ErrorMsg,
-    requires_comptime: bool,
-) !void {
-    if (!requires_comptime) return;
-
-    const src_loc = if (try sema.funcDeclSrc(block, func_src, func)) |capture| blk: {
-        var src_loc = capture;
-        src_loc.lazy = .{ .node_offset_fn_type_ret_ty = 0 };
-        break :blk src_loc;
-    } else blk: {
-        const src_decl = sema.mod.declPtr(block.src_decl);
-        break :blk func_src.toSrcLoc(src_decl);
-    };
-    if (return_ty.tag() == .generic_poison) {
-        return sema.mod.errNoteNonLazy(src_loc, parent, "generic function is instantiated with a comptime-only return type", .{});
-    }
-    try sema.mod.errNoteNonLazy(
-        src_loc,
-        parent,
-        "function is being called at comptime because it returns a comptime-only type '{}'",
-        .{return_ty.fmt(sema.mod)},
-    );
-    try sema.explainWhyTypeIsComptime(block, func_src, parent, src_loc, return_ty);
-}
-
 fn analyzeCall(
     sema: *Sema,
     block: *Block,
@@ -6177,11 +6211,21 @@ fn analyzeCall(
 
     var is_generic_call = func_ty_info.is_generic;
     var is_comptime_call = block.is_comptime or modifier == .compile_time;
-    var comptime_only_ret_ty = false;
+    var comptime_reason_buf: Block.ComptimeReason = undefined;
+    var comptime_reason: ?*const Block.ComptimeReason = null;
     if (!is_comptime_call) {
         if (sema.typeRequiresComptime(func_ty_info.return_type)) |ct| {
             is_comptime_call = ct;
-            comptime_only_ret_ty = ct;
+            if (ct) {
+                // stage1 can't handle doing this directly
+                comptime_reason_buf = .{ .comptime_ret_ty = .{
+                    .block = block,
+                    .func = func,
+                    .func_src = func_src,
+                    .return_ty = func_ty_info.return_type,
+                } };
+                comptime_reason = &comptime_reason_buf;
+            }
         } else |err| switch (err) {
             error.GenericPoison => is_generic_call = true,
             else => |e| return e,
@@ -6210,7 +6254,14 @@ fn analyzeCall(
             error.ComptimeReturn => {
                 is_inline_call = true;
                 is_comptime_call = true;
-                comptime_only_ret_ty = true;
+                // stage1 can't handle doing this directly
+                comptime_reason_buf = .{ .comptime_ret_ty = .{
+                    .block = block,
+                    .func = func,
+                    .func_src = func_src,
+                    .return_ty = func_ty_info.return_type,
+                } };
+                comptime_reason = &comptime_reason_buf;
             },
             else => |e| return e,
         }
@@ -6222,9 +6273,7 @@ fn analyzeCall(
 
     const result: Air.Inst.Ref = if (is_inline_call) res: {
         const func_val = sema.resolveConstValue(block, func_src, func, "function being called at comptime must be comptime-known") catch |err| {
-            if (err == error.AnalysisFail and sema.err != null) {
-                try sema.addComptimeReturnTypeNote(block, func, func_src, func_ty_info.return_type, sema.err.?, comptime_only_ret_ty);
-            }
+            if (err == error.AnalysisFail and comptime_reason != null) try comptime_reason.?.explain(sema, sema.err);
             return err;
         };
         const module_fn = switch (func_val.tag()) {
@@ -6292,6 +6341,7 @@ fn analyzeCall(
             .label = null,
             .inlining = &inlining,
             .is_comptime = is_comptime_call,
+            .comptime_reason = comptime_reason,
             .error_return_trace_index = block.error_return_trace_index,
         };
 
@@ -6344,11 +6394,6 @@ fn analyzeCall(
                 is_comptime_call,
                 &should_memoize,
                 memoized_call_key,
-                // last 4 arguments are only used when reporting errors
-                undefined,
-                undefined,
-                undefined,
-                undefined,
             ) catch |err| switch (err) {
                 error.NeededSourceLocation => {
                     _ = sema.inst_map.remove(inst);
@@ -6364,10 +6409,6 @@ fn analyzeCall(
                         is_comptime_call,
                         &should_memoize,
                         memoized_call_key,
-                        func,
-                        func_src,
-                        func_ty_info.return_type,
-                        comptime_only_ret_ty,
                     );
                     return error.AnalysisFail;
                 },
@@ -6604,10 +6645,6 @@ fn analyzeInlineCallArg(
     is_comptime_call: bool,
     should_memoize: *bool,
     memoized_call_key: Module.MemoizedCall.Key,
-    func: Air.Inst.Ref,
-    func_src: LazySrcLoc,
-    ret_ty: Type,
-    comptime_only_ret_ty: bool,
 ) !void {
     const zir_tags = sema.code.instructions.items(.tag);
     switch (zir_tags[inst]) {
@@ -6624,9 +6661,7 @@ fn analyzeInlineCallArg(
             const uncasted_arg = uncasted_args[arg_i.*];
             if (try sema.typeRequiresComptime(param_ty)) {
                 _ = sema.resolveConstMaybeUndefVal(arg_block, arg_src, uncasted_arg, "argument to parameter with comptime-only type must be comptime-known") catch |err| {
-                    if (err == error.AnalysisFail and sema.err != null) {
-                        try sema.addComptimeReturnTypeNote(arg_block, func, func_src, ret_ty, sema.err.?, comptime_only_ret_ty);
-                    }
+                    if (err == error.AnalysisFail and param_block.comptime_reason != null) try param_block.comptime_reason.?.explain(sema, sema.err);
                     return err;
                 };
             }
@@ -6635,9 +6670,7 @@ fn analyzeInlineCallArg(
             if (is_comptime_call) {
                 try sema.inst_map.putNoClobber(sema.gpa, inst, casted_arg);
                 const arg_val = sema.resolveConstMaybeUndefVal(arg_block, arg_src, casted_arg, "argument to function being called at comptime must be comptime-known") catch |err| {
-                    if (err == error.AnalysisFail and sema.err != null) {
-                        try sema.addComptimeReturnTypeNote(arg_block, func, func_src, ret_ty, sema.err.?, comptime_only_ret_ty);
-                    }
+                    if (err == error.AnalysisFail and param_block.comptime_reason != null) try param_block.comptime_reason.?.explain(sema, sema.err);
                     return err;
                 };
                 switch (arg_val.tag()) {
@@ -6679,9 +6712,7 @@ fn analyzeInlineCallArg(
             if (is_comptime_call) {
                 try sema.inst_map.putNoClobber(sema.gpa, inst, uncasted_arg);
                 const arg_val = sema.resolveConstMaybeUndefVal(arg_block, arg_src, uncasted_arg, "argument to function being called at comptime must be comptime-known") catch |err| {
-                    if (err == error.AnalysisFail and sema.err != null) {
-                        try sema.addComptimeReturnTypeNote(arg_block, func, func_src, ret_ty, sema.err.?, comptime_only_ret_ty);
-                    }
+                    if (err == error.AnalysisFail and param_block.comptime_reason != null) try param_block.comptime_reason.?.explain(sema, sema.err);
                     return err;
                 };
                 switch (arg_val.tag()) {
@@ -10223,6 +10254,7 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         .label = &label,
         .inlining = block.inlining,
         .is_comptime = block.is_comptime,
+        .comptime_reason = block.comptime_reason,
         .is_typeof = block.is_typeof,
         .switch_else_err_ty = else_error_ty,
         .runtime_cond = block.runtime_cond,
@@ -10333,7 +10365,13 @@ fn zirSwitchBlock(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError
         return sema.resolveBlockBody(block, src, &child_block, special.body, inst, merges);
     }
 
-    try sema.requireRuntimeBlock(block, src, operand_src);
+    if (child_block.is_comptime) {
+        _ = sema.resolveConstValue(&child_block, operand_src, operand, "condition in comptime switch must be comptime-known") catch |err| {
+            if (err == error.AnalysisFail and child_block.comptime_reason != null) try child_block.comptime_reason.?.explain(sema, sema.err);
+            return err;
+        };
+        unreachable;
+    }
 
     const estimated_cases_extra = (scalar_cases_len + multi_cases_len) *
         @typeInfo(Air.SwitchBr.Case).Struct.fields.len + 2;
@@ -21469,6 +21507,9 @@ fn requireRuntimeBlock(sema: *Sema, block: *Block, src: LazySrcLoc, runtime_src:
             if (runtime_src) |some| {
                 try sema.errNote(block, some, msg, "operation is runtime due to this operand", .{});
             }
+            if (block.comptime_reason) |some| {
+                try some.explain(sema, msg);
+            }
             break :msg msg;
         };
         return sema.failWithOwnedErrorMsg(msg);
@@ -21940,6 +21981,7 @@ fn addSafetyCheck(
     panic_id: PanicId,
 ) !void {
     const gpa = sema.gpa;
+    assert(!parent_block.is_comptime);
 
     var fail_block: Block = .{
         .parent = parent_block,
@@ -21949,7 +21991,7 @@ fn addSafetyCheck(
         .wip_capture_scope = parent_block.wip_capture_scope,
         .instructions = .{},
         .inlining = parent_block.inlining,
-        .is_comptime = parent_block.is_comptime,
+        .is_comptime = false,
     };
 
     defer fail_block.instructions.deinit(gpa);
@@ -22061,6 +22103,7 @@ fn panicUnwrapError(
     unwrap_err_tag: Air.Inst.Tag,
     is_non_err_tag: Air.Inst.Tag,
 ) !void {
+    assert(!parent_block.is_comptime);
     const ok = try parent_block.addUnOp(is_non_err_tag, operand);
     const gpa = sema.gpa;
 
@@ -22072,7 +22115,7 @@ fn panicUnwrapError(
         .wip_capture_scope = parent_block.wip_capture_scope,
         .instructions = .{},
         .inlining = parent_block.inlining,
-        .is_comptime = parent_block.is_comptime,
+        .is_comptime = false,
     };
 
     defer fail_block.instructions.deinit(gpa);
@@ -22104,6 +22147,7 @@ fn panicIndexOutOfBounds(
     len: Air.Inst.Ref,
     cmp_op: Air.Inst.Tag,
 ) !void {
+    assert(!parent_block.is_comptime);
     const ok = try parent_block.addBinOp(cmp_op, index, len);
     const gpa = sema.gpa;
 
@@ -22115,7 +22159,7 @@ fn panicIndexOutOfBounds(
         .wip_capture_scope = parent_block.wip_capture_scope,
         .instructions = .{},
         .inlining = parent_block.inlining,
-        .is_comptime = parent_block.is_comptime,
+        .is_comptime = false,
     };
 
     defer fail_block.instructions.deinit(gpa);
@@ -22146,6 +22190,7 @@ fn panicSentinelMismatch(
     ptr: Air.Inst.Ref,
     sentinel_index: Air.Inst.Ref,
 ) !void {
+    assert(!parent_block.is_comptime);
     const expected_sentinel_val = maybe_sentinel orelse return;
     const expected_sentinel = try sema.addConstant(sentinel_ty, expected_sentinel_val);
 
@@ -22186,7 +22231,7 @@ fn panicSentinelMismatch(
         .wip_capture_scope = parent_block.wip_capture_scope,
         .instructions = .{},
         .inlining = parent_block.inlining,
-        .is_comptime = parent_block.is_comptime,
+        .is_comptime = false,
     };
 
     defer fail_block.instructions.deinit(gpa);
diff --git a/test/cases/compile_errors/condition_comptime_reason_explained.zig b/test/cases/compile_errors/condition_comptime_reason_explained.zig
new file mode 100644
index 0000000000..332ae8afc8
--- /dev/null
+++ b/test/cases/compile_errors/condition_comptime_reason_explained.zig
@@ -0,0 +1,48 @@
+const S = struct {
+    fnPtr: fn () void,
+};
+fn bar() void {}
+fn baz() void {}
+var runtime: bool = true;
+fn ifExpr() S {
+    if (runtime) {
+        return .{
+            .fnPtr = bar,
+        };
+    } else {
+        return .{
+            .fnPtr = baz,
+        };
+    }
+}
+pub export fn entry1() void {
+    _ = ifExpr();
+}
+fn switchExpr() S {
+    switch (runtime) {
+        true => return .{
+            .fnPtr = bar,
+        },
+        false => return .{
+            .fnPtr = baz,
+        },
+    }
+}
+pub export fn entry2() void {
+    _ = switchExpr();
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :8:9: error: unable to resolve comptime value
+// :8:9: note: condition in comptime branch must be comptime-known
+// :7:13: note: expression is evaluated at comptime because the function returns a comptime-only type 'tmp.S'
+// :2:12: note: struct requires comptime because of this field
+// :2:12: note: use '*const fn() void' for a function pointer type
+// :19:15: note: called from here
+// :22:13: error: unable to resolve comptime value
+// :22:13: note: condition in comptime switch must be comptime-known
+// :21:17: note: expression is evaluated at comptime because the function returns a comptime-only type 'tmp.S'
+// :32:19: note: called from here
diff --git a/test/cases/compile_errors/explain_why_fn_is_called_at_comptime.zig b/test/cases/compile_errors/explain_why_fn_is_called_at_comptime.zig
index d19ab31617..83d5d7e33f 100644
--- a/test/cases/compile_errors/explain_why_fn_is_called_at_comptime.zig
+++ b/test/cases/compile_errors/explain_why_fn_is_called_at_comptime.zig
@@ -18,6 +18,6 @@ pub export fn entry() void {
 //
 // :12:13: error: unable to resolve comptime value
 // :12:13: note: argument to function being called at comptime must be comptime-known
-// :7:25: note: function is being called at comptime because it returns a comptime-only type 'tmp.S'
+// :7:25: note: expression is evaluated at comptime because the function returns a comptime-only type 'tmp.S'
 // :2:12: note: struct requires comptime because of this field
 // :2:12: note: use '*const fn() void' for a function pointer type
diff --git a/test/cases/compile_errors/explain_why_generic_fn_is_called_at_comptime.zig b/test/cases/compile_errors/explain_why_generic_fn_is_called_at_comptime.zig
index 36aeb40479..701241a403 100644
--- a/test/cases/compile_errors/explain_why_generic_fn_is_called_at_comptime.zig
+++ b/test/cases/compile_errors/explain_why_generic_fn_is_called_at_comptime.zig
@@ -19,4 +19,4 @@ pub export fn entry() void {
 //
 // :14:13: error: unable to resolve comptime value
 // :14:13: note: argument to function being called at comptime must be comptime-known
-// :9:38: note: generic function is instantiated with a comptime-only return type
+// :9:38: note: expression is evaluated at comptime because the generic function was instantiated with a comptime-only return type
diff --git a/test/cases/compile_errors/unable_to_evaluate_expr_inside_cimport.zig b/test/cases/compile_errors/unable_to_evaluate_expr_inside_cimport.zig
new file mode 100644
index 0000000000..9460a58993
--- /dev/null
+++ b/test/cases/compile_errors/unable_to_evaluate_expr_inside_cimport.zig
@@ -0,0 +1,15 @@
+const c = @cImport({
+    _ = 1 + foo;
+});
+extern var foo: i32;
+export fn entry() void {
+    _ = c;
+}
+
+// error
+// backend=llvm
+// target=native
+//
+// :2:11: error: unable to evaluate comptime expression
+// :2:13: note: operation is runtime due to this operand
+// :1:11: note: expression is evaluated at comptime because it is inside a @cImport
diff --git a/test/compile_errors.zig b/test/compile_errors.zig
index e9b08565ce..5454124df8 100644
--- a/test/compile_errors.zig
+++ b/test/compile_errors.zig
@@ -204,7 +204,7 @@ pub fn addCases(ctx: *TestContext) !void {
         , &[_][]const u8{
             ":3:12: error: unable to resolve comptime value",
             ":3:12: note: argument to function being called at comptime must be comptime-known",
-            ":2:55: note: generic function is instantiated with a comptime-only return type",
+            ":2:55: note: expression is evaluated at comptime because the generic function was instantiated with a comptime-only return type",
         });
     }
 

From 6fc71835c3075aff4792b63bc38698cbe542f028 Mon Sep 17 00:00:00 2001
From: Veikka Tuominen <git@vexu.eu>
Date: Fri, 28 Oct 2022 00:07:38 +0300
Subject: [PATCH 55/70] value: properly hash `null_value` pointer

Closes #13325
---
 src/value.zig              | 1 +
 test/behavior/generics.zig | 9 +++++++++
 2 files changed, 10 insertions(+)

diff --git a/src/value.zig b/src/value.zig
index 28601c1723..7d01430103 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -2621,6 +2621,7 @@ pub const Value = extern union {
 
             .zero,
             .one,
+            .null_value,
             .int_u64,
             .int_i64,
             .int_big_positive,
diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig
index 4a483ec0d5..9513118c19 100644
--- a/test/behavior/generics.zig
+++ b/test/behavior/generics.zig
@@ -396,3 +396,12 @@ test "slice as parameter type" {
     try expect(S.internComptimeString(source_a[1..2]) == S.internComptimeString(source_a[1..2]));
     try expect(S.internComptimeString(source_a[2..4]) != S.internComptimeString(source_a[5..7]));
 }
+
+test "null sentinel pointer passed as generic argument" {
+    const S = struct {
+        fn doTheTest(a: anytype) !void {
+            try std.testing.expect(@ptrToInt(a) == 8);
+        }
+    };
+    try S.doTheTest((@intToPtr([*:null]const [*c]const u8, 8)));
+}

From d6943f87f9cb5607fb18a85b985bb6193e8107ae Mon Sep 17 00:00:00 2001
From: Ali Chraghi <63465728+alichraghi@users.noreply.github.com>
Date: Tue, 25 Oct 2022 19:51:16 +0330
Subject: [PATCH 56/70] NativeTargetInfo: remove unused error

---
 lib/std/zig/system/NativeTargetInfo.zig | 1 -
 1 file changed, 1 deletion(-)

diff --git a/lib/std/zig/system/NativeTargetInfo.zig b/lib/std/zig/system/NativeTargetInfo.zig
index 7a31dfa44f..c7b3f73f89 100644
--- a/lib/std/zig/system/NativeTargetInfo.zig
+++ b/lib/std/zig/system/NativeTargetInfo.zig
@@ -20,7 +20,6 @@ dynamic_linker: DynamicLinker = DynamicLinker{},
 pub const DynamicLinker = Target.DynamicLinker;
 
 pub const DetectError = error{
-    OutOfMemory,
     FileSystem,
     SystemResources,
     SymLinkLoop,

From f28e4e03eeb622d1cfd391cf9f0c7e45f4d80681 Mon Sep 17 00:00:00 2001
From: Frank Denis <124872+jedisct1@users.noreply.github.com>
Date: Fri, 28 Oct 2022 16:25:37 +0200
Subject: [PATCH 57/70] std.sign.ecdsa: add support for incremental signatures
 (#13332)

Similar to what was done for EdDSA, allow incremental creation
and verification of ECDSA signatures.

Doing so for ECDSA is trivial, and can be useful for TLS as well
as the future package manager.
---
 lib/std/crypto/ecdsa.zig | 160 +++++++++++++++++++++++++++------------
 1 file changed, 113 insertions(+), 47 deletions(-)

diff --git a/lib/std/crypto/ecdsa.zig b/lib/std/crypto/ecdsa.zig
index ee27e23a75..a0faa3da54 100644
--- a/lib/std/crypto/ecdsa.zig
+++ b/lib/std/crypto/ecdsa.zig
@@ -84,34 +84,18 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             /// The S component of an ECDSA signature.
             s: Curve.scalar.CompressedScalar,
 
+            /// Create a Verifier for incremental verification of a signature.
+            pub fn verifier(self: Signature, public_key: PublicKey) (NonCanonicalError || EncodingError || IdentityElementError)!Verifier {
+                return Verifier.init(self, public_key);
+            }
+
             /// Verify the signature against a message and public key.
             /// Return IdentityElement or NonCanonical if the public key or signature are not in the expected range,
             /// or SignatureVerificationError if the signature is invalid for the given message and key.
             pub fn verify(self: Signature, msg: []const u8, public_key: PublicKey) (IdentityElementError || NonCanonicalError || SignatureVerificationError)!void {
-                const r = try Curve.scalar.Scalar.fromBytes(self.r, .Big);
-                const s = try Curve.scalar.Scalar.fromBytes(self.s, .Big);
-                if (r.isZero() or s.isZero()) return error.IdentityElement;
-
-                const ht = Curve.scalar.encoded_length;
-                const h_len = @max(Hash.digest_length, ht);
-                var h: [h_len]u8 = [_]u8{0} ** h_len;
-                Hash.hash(msg, h[h_len - Hash.digest_length .. h_len], .{});
-
-                const z = reduceToScalar(ht, h[0..ht].*);
-                if (z.isZero()) {
-                    return error.SignatureVerificationFailed;
-                }
-
-                const s_inv = s.invert();
-                const v1 = z.mul(s_inv).toBytes(.Little);
-                const v2 = r.mul(s_inv).toBytes(.Little);
-                const v1g = try Curve.basePoint.mulPublic(v1, .Little);
-                const v2pk = try public_key.p.mulPublic(v2, .Little);
-                const vxs = v1g.add(v2pk).affineCoordinates().x.toBytes(.Big);
-                const vr = reduceToScalar(Curve.Fe.encoded_length, vxs);
-                if (!r.equivalent(vr)) {
-                    return error.SignatureVerificationFailed;
-                }
+                var st = try Verifier.init(self, public_key);
+                st.update(msg);
+                return st.verify();
             }
 
             /// Return the raw signature (r, s) in big-endian format.
@@ -191,6 +175,104 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             }
         };
 
+        /// A Signer is used to incrementally compute a signature.
+        /// It can be obtained from a `KeyPair`, using the `signer()` function.
+        pub const Signer = struct {
+            h: Hash,
+            secret_key: SecretKey,
+            noise: ?[noise_length]u8,
+
+            fn init(secret_key: SecretKey, noise: ?[noise_length]u8) !Signer {
+                return Signer{
+                    .h = Hash.init(.{}),
+                    .secret_key = secret_key,
+                    .noise = noise,
+                };
+            }
+
+            /// Add new data to the message being signed.
+            pub fn update(self: *Signer, data: []const u8) void {
+                self.h.update(data);
+            }
+
+            /// Compute a signature over the entire message.
+            pub fn finalize(self: *Signer) (IdentityElementError || NonCanonicalError)!Signature {
+                const scalar_encoded_length = Curve.scalar.encoded_length;
+                const h_len = @max(Hash.digest_length, scalar_encoded_length);
+                var h: [h_len]u8 = [_]u8{0} ** h_len;
+                var h_slice = h[h_len - Hash.digest_length .. h_len];
+                self.h.final(h_slice);
+
+                std.debug.assert(h.len >= scalar_encoded_length);
+                const z = reduceToScalar(scalar_encoded_length, h[0..scalar_encoded_length].*);
+
+                const k = deterministicScalar(h_slice.*, self.secret_key.bytes, self.noise);
+
+                const p = try Curve.basePoint.mul(k.toBytes(.Big), .Big);
+                const xs = p.affineCoordinates().x.toBytes(.Big);
+                const r = reduceToScalar(Curve.Fe.encoded_length, xs);
+                if (r.isZero()) return error.IdentityElement;
+
+                const k_inv = k.invert();
+                const zrs = z.add(r.mul(try Curve.scalar.Scalar.fromBytes(self.secret_key.bytes, .Big)));
+                const s = k_inv.mul(zrs);
+                if (s.isZero()) return error.IdentityElement;
+
+                return Signature{ .r = r.toBytes(.Big), .s = s.toBytes(.Big) };
+            }
+        };
+
+        /// A Verifier is used to incrementally verify a signature.
+        /// It can be obtained from a `Signature`, using the `verifier()` function.
+        pub const Verifier = struct {
+            h: Hash,
+            r: Curve.scalar.Scalar,
+            s: Curve.scalar.Scalar,
+            public_key: PublicKey,
+
+            fn init(sig: Signature, public_key: PublicKey) (IdentityElementError || NonCanonicalError)!Verifier {
+                const r = try Curve.scalar.Scalar.fromBytes(sig.r, .Big);
+                const s = try Curve.scalar.Scalar.fromBytes(sig.s, .Big);
+                if (r.isZero() or s.isZero()) return error.IdentityElement;
+
+                return Verifier{
+                    .h = Hash.init(.{}),
+                    .r = r,
+                    .s = s,
+                    .public_key = public_key,
+                };
+            }
+
+            /// Add new content to the message to be verified.
+            pub fn update(self: *Verifier, data: []const u8) void {
+                self.h.update(data);
+            }
+
+            /// Verify that the signature is valid for the entire message.
+            pub fn verify(self: *Verifier) (IdentityElementError || SignatureVerificationError)!void {
+                const ht = Curve.scalar.encoded_length;
+                const h_len = @max(Hash.digest_length, ht);
+                var h: [h_len]u8 = [_]u8{0} ** h_len;
+                self.h.final(h[h_len - Hash.digest_length .. h_len]);
+
+                const z = reduceToScalar(ht, h[0..ht].*);
+                if (z.isZero()) {
+                    return error.SignatureVerificationFailed;
+                }
+
+                const s_inv = self.s.invert();
+                const v1 = z.mul(s_inv).toBytes(.Little);
+                const v2 = self.r.mul(s_inv).toBytes(.Little);
+                const v1g = try Curve.basePoint.mulPublic(v1, .Little);
+                const v2pk = try self.public_key.p.mulPublic(v2, .Little);
+                const vxs = v1g.add(v2pk).affineCoordinates().x.toBytes(.Big);
+                const vr = reduceToScalar(Curve.Fe.encoded_length, vxs);
+                if (!self.r.equivalent(vr)) {
+                    return error.SignatureVerificationFailed;
+                }
+            }
+        };
+
         /// An ECDSA key pair.
         pub const KeyPair = struct {
             /// Length (in bytes) of a seed required to create a key pair.
@@ -227,30 +309,14 @@ pub fn Ecdsa(comptime Curve: type, comptime Hash: type) type {
             /// If deterministic signatures are not required, the noise should be randomly generated instead.
             /// This helps defend against fault attacks.
             pub fn sign(key_pair: KeyPair, msg: []const u8, noise: ?[noise_length]u8) (IdentityElementError || NonCanonicalError)!Signature {
-                const secret_key = key_pair.secret_key;
+                var st = try key_pair.signer(noise);
+                st.update(msg);
+                return st.finalize();
+            }
 
-                const scalar_encoded_length = Curve.scalar.encoded_length;
-                const h_len = @max(Hash.digest_length, scalar_encoded_length);
-                var h: [h_len]u8 = [_]u8{0} ** h_len;
-                var h_slice = h[h_len - Hash.digest_length .. h_len];
-                Hash.hash(msg, h_slice, .{});
-
-                std.debug.assert(h.len >= scalar_encoded_length);
-                const z = reduceToScalar(scalar_encoded_length, h[0..scalar_encoded_length].*);
-
-                const k = deterministicScalar(h_slice.*, secret_key.bytes, noise);
-
-                const p = try Curve.basePoint.mul(k.toBytes(.Big), .Big);
-                const xs = p.affineCoordinates().x.toBytes(.Big);
-                const r = reduceToScalar(Curve.Fe.encoded_length, xs);
-                if (r.isZero()) return error.IdentityElement;
-
-                const k_inv = k.invert();
-                const zrs = z.add(r.mul(try Curve.scalar.Scalar.fromBytes(secret_key.bytes, .Big)));
-                const s = k_inv.mul(zrs);
-                if (s.isZero()) return error.IdentityElement;
-
-                return Signature{ .r = r.toBytes(.Big), .s = s.toBytes(.Big) };
+            /// Create a Signer, that can be used for incremental signature verification.
+            pub fn signer(key_pair: KeyPair, noise: ?[noise_length]u8) !Signer {
+                return Signer.init(key_pair.secret_key, noise);
             }
         };
 

From c639c225444c9252515949786e139494fb728861 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Tue, 18 Oct 2022 11:33:24 -0700
Subject: [PATCH 58/70] std.mem: Add readPackedInt, writePackedInt, etc.

These utility functions allow reading from (stage2) packed memory at
runtime-known offsets.
---
 lib/std/mem.zig | 460 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 460 insertions(+)

diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index 4000030fc0..f0403942f1 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -1298,6 +1298,76 @@ pub fn readVarInt(comptime ReturnType: type, bytes: []const u8, endian: Endian)
     return result;
 }
 
+/// Loads an integer from packed memory with provided bit_count, bit_offset, and signedness.
+/// Asserts that T is large enough to store the read value.
+///
+/// Example:
+///     const T = packed struct(u16){ a: u3, b: u7, c: u6 };
+///     var st = T{ .a = 1, .b = 2, .c = 4 };
+///     const b_field = readVarPackedInt(u64, std.mem.asBytes(&st), @bitOffsetOf(T, "b"), 7, builtin.cpu.arch.endian(), .unsigned);
+///
+pub fn readVarPackedInt(
+    comptime T: type,
+    bytes: []const u8,
+    bit_offset: usize,
+    bit_count: usize,
+    endian: std.builtin.Endian,
+    signedness: std.builtin.Signedness,
+) T {
+    const uN = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const iN = std.meta.Int(.signed, @bitSizeOf(T));
+    const Log2N = std.math.Log2Int(T);
+
+    const read_size = (bit_count + (bit_offset % 8) + 7) / 8;
+    const bit_shift = @intCast(u3, bit_offset % 8);
+    const pad = @intCast(Log2N, @bitSizeOf(T) - bit_count);
+
+    const lowest_byte = switch (endian) {
+        .Big => bytes.len - (bit_offset / 8) - read_size,
+        .Little => bit_offset / 8,
+    };
+    const read_bytes = bytes[lowest_byte..][0..read_size];
+
+    if (@bitSizeOf(T) <= 8) {
+        // These are the same shifts/masks we perform below, but adds `@truncate`/`@intCast`
+        // where needed since int is smaller than a byte.
+        const value = if (read_size == 1) b: {
+            break :b @truncate(uN, read_bytes[0] >> bit_shift);
+        } else b: {
+            const i: u1 = @boolToInt(endian == .Big);
+            const head = @truncate(uN, read_bytes[i] >> bit_shift);
+            const tail_shift = @intCast(Log2N, @as(u4, 8) - bit_shift);
+            const tail = @truncate(uN, read_bytes[1 - i]);
+            break :b (tail << tail_shift) | head;
+        };
+        switch (signedness) {
+            .signed => return @intCast(T, (@bitCast(iN, value) << pad) >> pad),
+            .unsigned => return @intCast(T, (@bitCast(uN, value) << pad) >> pad),
+        }
+    }
+
+    // Copy the value out (respecting endianness), accounting for bit_shift
+    var int: uN = 0;
+    switch (endian) {
+        .Big => {
+            for (read_bytes[0 .. read_size - 1]) |elem| {
+                int = elem | (int << 8);
+            }
+            int = (read_bytes[read_size - 1] >> bit_shift) | (int << (@as(u4, 8) - bit_shift));
+        },
+        .Little => {
+            int = read_bytes[0] >> bit_shift;
+            for (read_bytes[1..]) |elem, i| {
+                int |= (@as(uN, elem) << @intCast(Log2N, (8 * (i + 1) - bit_shift)));
+            }
+        },
+    }
+    switch (signedness) {
+        .signed => return @intCast(T, (@bitCast(iN, int) << pad) >> pad),
+        .unsigned => return @intCast(T, (@bitCast(uN, int) << pad) >> pad),
+    }
+}
+
 /// Reads an integer from memory with bit count specified by T.
 /// The bit count of T must be evenly divisible by 8.
 /// This function cannot fail and cannot cause undefined behavior.
@@ -1365,6 +1435,84 @@ pub fn readInt(comptime T: type, bytes: *const [@divExact(@typeInfo(T).Int.bits,
     }
 }
 
+fn readPackedIntLittle(comptime T: type, bytes: []const u8, bit_offset: usize) T {
+    const uN = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const Log2N = std.math.Log2Int(T);
+
+    const bit_count = @as(usize, @bitSizeOf(T));
+    const bit_shift = @intCast(u3, bit_offset % 8);
+
+    const load_size = (bit_count + 7) / 8;
+    const load_tail_bits = @intCast(u3, (load_size * 8) - bit_count);
+    const LoadInt = std.meta.Int(.unsigned, load_size * 8);
+
+    if (bit_count == 0)
+        return 0;
+
+    // Read by loading a LoadInt, and then follow it up with a 1-byte read
+    // of the tail if bit_offset pushed us over a byte boundary.
+    const read_bytes = bytes[bit_offset / 8 ..];
+    const val = @truncate(uN, readIntLittle(LoadInt, read_bytes[0..load_size]) >> bit_shift);
+    if (bit_shift > load_tail_bits) {
+        const tail_bits = @intCast(Log2N, bit_shift - load_tail_bits);
+        const tail_byte = read_bytes[load_size];
+        const tail_truncated = if (bit_count < 8) @truncate(uN, tail_byte) else @as(uN, tail_byte);
+        return @bitCast(T, val | (tail_truncated << (@truncate(Log2N, bit_count) -% tail_bits)));
+    } else return @bitCast(T, val);
+}
+
+fn readPackedIntBig(comptime T: type, bytes: []const u8, bit_offset: usize) T {
+    const uN = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const Log2N = std.math.Log2Int(T);
+
+    const bit_count = @as(usize, @bitSizeOf(T));
+    const bit_shift = @intCast(u3, bit_offset % 8);
+    const byte_count = (@as(usize, bit_shift) + bit_count + 7) / 8;
+
+    const load_size = (bit_count + 7) / 8;
+    const load_tail_bits = @intCast(u3, (load_size * 8) - bit_count);
+    const LoadInt = std.meta.Int(.unsigned, load_size * 8);
+
+    if (bit_count == 0)
+        return 0;
+
+    // Read by loading a LoadInt, and then follow it up with a 1-byte read
+    // of the tail if bit_offset pushed us over a byte boundary.
+    const end = bytes.len - (bit_offset / 8);
+    const read_bytes = bytes[(end - byte_count)..end];
+    const val = @truncate(uN, readIntBig(LoadInt, bytes[(end - load_size)..end][0..load_size]) >> bit_shift);
+    if (bit_shift > load_tail_bits) {
+        const tail_bits = @intCast(Log2N, bit_shift - load_tail_bits);
+        const tail_byte = if (bit_count < 8) @truncate(uN, read_bytes[0]) else @as(uN, read_bytes[0]);
+        return @bitCast(T, val | (tail_byte << (@truncate(Log2N, bit_count) -% tail_bits)));
+    } else return @bitCast(T, val);
+}
+
+pub const readPackedIntNative = switch (native_endian) {
+    .Little => readPackedIntLittle,
+    .Big => readPackedIntBig,
+};
+
+pub const readPackedIntForeign = switch (native_endian) {
+    .Little => readPackedIntBig,
+    .Big => readPackedIntLittle,
+};
+
+/// Loads an integer from packed memory.
+/// Asserts that buffer contains at least bit_offset + @bitSizeOf(T) bits.
+///
+/// Example:
+///     const T = packed struct(u16){ a: u3, b: u7, c: u6 };
+///     var st = T{ .a = 1, .b = 2, .c = 4 };
+///     const b_field = readPackedInt(u7, std.mem.asBytes(&st), @bitOffsetOf(T, "b"), builtin.cpu.arch.endian());
+///
+pub fn readPackedInt(comptime T: type, bytes: []const u8, bit_offset: usize, endian: Endian) T {
+    switch (endian) {
+        .Little => return readPackedIntLittle(T, bytes, bit_offset),
+        .Big => return readPackedIntBig(T, bytes, bit_offset),
+    }
+}
+
 /// Asserts that bytes.len >= @typeInfo(T).Int.bits / 8. Reads the integer starting from index 0
 /// and ignores extra bytes.
 /// The bit count of T must be evenly divisible by 8.
@@ -1447,6 +1595,100 @@ pub fn writeInt(comptime T: type, buffer: *[@divExact(@typeInfo(T).Int.bits, 8)]
     }
 }
 
+pub fn writePackedIntLittle(comptime T: type, bytes: []u8, bit_offset: usize, value: T) void {
+    const uN = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const Log2N = std.math.Log2Int(T);
+
+    const bit_count = @as(usize, @bitSizeOf(T));
+    const bit_shift = @intCast(u3, bit_offset % 8);
+
+    const store_size = (@bitSizeOf(T) + 7) / 8;
+    const store_tail_bits = @intCast(u3, (store_size * 8) - bit_count);
+    const StoreInt = std.meta.Int(.unsigned, store_size * 8);
+
+    if (bit_count == 0)
+        return;
+
+    // Write by storing a StoreInt, and then follow it up with a 1-byte tail
+    // if bit_offset pushed us over a byte boundary.
+    const write_bytes = bytes[bit_offset / 8 ..];
+    const head = write_bytes[0] & ((@as(u8, 1) << bit_shift) - 1);
+
+    var write_value = (@as(StoreInt, @bitCast(uN, value)) << bit_shift) | @intCast(StoreInt, head);
+    if (bit_shift > store_tail_bits) {
+        const tail_len = @intCast(Log2N, bit_shift - store_tail_bits);
+        write_bytes[store_size] &= ~((@as(u8, 1) << @intCast(u3, tail_len)) - 1);
+        write_bytes[store_size] |= @intCast(u8, (@bitCast(uN, value) >> (@truncate(Log2N, bit_count) -% tail_len)));
+    } else if (bit_shift < store_tail_bits) {
+        const tail_len = store_tail_bits - bit_shift;
+        const tail = write_bytes[store_size - 1] & (@as(u8, 0xfe) << (7 - tail_len));
+        write_value |= @as(StoreInt, tail) << (8 * (store_size - 1));
+    }
+
+    writeIntLittle(StoreInt, write_bytes[0..store_size], write_value);
+}
+
+pub fn writePackedIntBig(comptime T: type, bytes: []u8, bit_offset: usize, value: T) void {
+    const uN = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const Log2N = std.math.Log2Int(T);
+
+    const bit_count = @as(usize, @bitSizeOf(T));
+    const bit_shift = @intCast(u3, bit_offset % 8);
+    const byte_count = (bit_shift + bit_count + 7) / 8;
+
+    const store_size = (@bitSizeOf(T) + 7) / 8;
+    const store_tail_bits = @intCast(u3, (store_size * 8) - bit_count);
+    const StoreInt = std.meta.Int(.unsigned, store_size * 8);
+
+    if (bit_count == 0)
+        return;
+
+    // Write by storing a StoreInt, and then follow it up with a 1-byte tail
+    // if bit_offset pushed us over a byte boundary.
+    const end = bytes.len - (bit_offset / 8);
+    const write_bytes = bytes[(end - byte_count)..end];
+    const head = write_bytes[byte_count - 1] & ((@as(u8, 1) << bit_shift) - 1);
+
+    var write_value = (@as(StoreInt, @bitCast(uN, value)) << bit_shift) | @intCast(StoreInt, head);
+    if (bit_shift > store_tail_bits) {
+        const tail_len = @intCast(Log2N, bit_shift - store_tail_bits);
+        write_bytes[0] &= ~((@as(u8, 1) << @intCast(u3, tail_len)) - 1);
+        write_bytes[0] |= @intCast(u8, (@bitCast(uN, value) >> (@truncate(Log2N, bit_count) -% tail_len)));
+    } else if (bit_shift < store_tail_bits) {
+        const tail_len = store_tail_bits - bit_shift;
+        const tail = write_bytes[0] & (@as(u8, 0xfe) << (7 - tail_len));
+        write_value |= @as(StoreInt, tail) << (8 * (store_size - 1));
+    }
+
+    writeIntBig(StoreInt, write_bytes[(byte_count - store_size)..][0..store_size], write_value);
+}
+
+pub const writePackedIntNative = switch (native_endian) {
+    .Little => writePackedIntLittle,
+    .Big => writePackedIntBig,
+};
+
+pub const writePackedIntForeign = switch (native_endian) {
+    .Little => writePackedIntBig,
+    .Big => writePackedIntLittle,
+};
+
+/// Stores an integer to packed memory.
+/// Asserts that buffer contains at least bit_offset + @bitSizeOf(T) bits.
+///
+/// Example:
+///     const T = packed struct(u16){ a: u3, b: u7, c: u6 };
+///     var st = T{ .a = 1, .b = 2, .c = 4 };
+///     // st.b = 0x7f;
+///     writePackedInt(u7, std.mem.asBytes(&st), @bitOffsetOf(T, "b"), 0x7f, builtin.cpu.arch.endian());
+///
+pub fn writePackedInt(comptime T: type, bytes: []u8, bit_offset: usize, value: T, endian: Endian) void {
+    switch (endian) {
+        .Little => writePackedIntLittle(T, bytes, bit_offset, value),
+        .Big => writePackedIntBig(T, bytes, bit_offset, value),
+    }
+}
+
 /// Writes a twos-complement little-endian integer to memory.
 /// Asserts that buf.len >= @typeInfo(T).Int.bits / 8.
 /// The bit count of T must be divisible by 8.
@@ -1523,6 +1765,69 @@ pub fn writeIntSlice(comptime T: type, buffer: []u8, value: T, endian: Endian) v
     };
 }
 
+/// Stores an integer to packed memory with provided bit_count, bit_offset, and signedness.
+/// If negative, the written value is sign-extended.
+///
+/// Example:
+///     const T = packed struct(u16){ a: u3, b: u7, c: u6 };
+///     var st = T{ .a = 1, .b = 2, .c = 4 };
+///     // st.b = 0x7f;
+///     var value: u64 = 0x7f;
+///     writeVarPackedInt(std.mem.asBytes(&st), @bitOffsetOf(T, "b"), 7, value, builtin.cpu.arch.endian());
+///
+pub fn writeVarPackedInt(bytes: []u8, bit_offset: usize, bit_count: usize, value: anytype, endian: std.builtin.Endian) void {
+    const T = @TypeOf(value);
+    const uN = std.meta.Int(.unsigned, @bitSizeOf(T));
+    const Log2N = std.math.Log2Int(T);
+
+    const bit_shift = @intCast(u3, bit_offset % 8);
+    const write_size = (bit_count + bit_shift + 7) / 8;
+    const lowest_byte = switch (endian) {
+        .Big => bytes.len - (bit_offset / 8) - write_size,
+        .Little => bit_offset / 8,
+    };
+    const write_bytes = bytes[lowest_byte..][0..write_size];
+
+    if (write_size == 1) {
+        // Single byte writes are handled specially, since we need to mask bits
+        // on both ends of the byte.
+        const mask = (@as(u8, 0xff) >> @intCast(u3, 8 - bit_count));
+        const new_bits = @intCast(u8, @bitCast(uN, value) & mask) << bit_shift;
+        write_bytes[0] = (write_bytes[0] & ~(mask << bit_shift)) | new_bits;
+        return;
+    }
+
+    var remaining: T = value;
+
+    // Iterate bytes forward for Little-endian, backward for Big-endian
+    const delta: i2 = if (endian == .Big) -1 else 1;
+    const start = if (endian == .Big) @intCast(isize, write_bytes.len - 1) else 0;
+
+    var i: isize = start; // isize for signed index arithmetic
+
+    // Write first byte, using a mask to protects bits preceding bit_offset
+    const head_mask = @as(u8, 0xff) >> bit_shift;
+    write_bytes[@intCast(usize, i)] &= ~(head_mask << bit_shift);
+    write_bytes[@intCast(usize, i)] |= @intCast(u8, @bitCast(uN, remaining) & head_mask) << bit_shift;
+    remaining >>= @intCast(Log2N, @as(u4, 8) - bit_shift);
+    i += delta;
+
+    // Write bytes[1..bytes.len - 1]
+    if (@bitSizeOf(T) > 8) {
+        const loop_end = start + delta * (@intCast(isize, write_size) - 1);
+        while (i != loop_end) : (i += delta) {
+            write_bytes[@intCast(usize, i)] = @truncate(u8, @bitCast(uN, remaining));
+            remaining >>= 8;
+        }
+    }
+
+    // Write last byte, using a mask to protect bits following bit_offset + bit_count
+    const following_bits = -%@truncate(u3, bit_shift + bit_count);
+    const tail_mask = (@as(u8, 0xff) << following_bits) >> following_bits;
+    write_bytes[@intCast(usize, i)] &= ~tail_mask;
+    write_bytes[@intCast(usize, i)] |= @intCast(u8, @bitCast(uN, remaining) & tail_mask);
+}
+
 test "writeIntBig and writeIntLittle" {
     var buf0: [0]u8 = undefined;
     var buf1: [1]u8 = undefined;
@@ -3393,3 +3698,158 @@ pub fn alignInSlice(slice: anytype, comptime new_alignment: usize) ?AlignedSlice
     const aligned_slice = bytesAsSlice(Element, aligned_bytes[0..slice_length_bytes]);
     return @alignCast(new_alignment, aligned_slice);
 }
+
+test "read/write(Var)PackedInt" {
+    const foreign_endian: Endian = if (native_endian == .Big) .Little else .Big;
+    const expect = std.testing.expect;
+    var prng = std.rand.DefaultPrng.init(1234);
+    const random = prng.random();
+
+    @setEvalBranchQuota(10_000);
+    inline for ([_]type{ u8, u16, u32, u128 }) |BackingType| {
+        for ([_]BackingType{
+            @as(BackingType, 0), // all zeros
+            -%@as(BackingType, 1), // all ones
+            random.int(BackingType), // random
+            random.int(BackingType), // random
+            random.int(BackingType), // random
+        }) |init_value| {
+            const uTs = [_]type{ u1, u3, u7, u8, u9, u10, u15, u16, u86 };
+            const iTs = [_]type{ i1, i3, i7, i8, i9, i10, i15, i16, i86 };
+            inline for (uTs ++ iTs) |PackedType| {
+                if (@bitSizeOf(PackedType) > @bitSizeOf(BackingType))
+                    continue;
+
+                const iPackedType = std.meta.Int(.signed, @bitSizeOf(PackedType));
+                const uPackedType = std.meta.Int(.unsigned, @bitSizeOf(PackedType));
+                const Log2T = std.math.Log2Int(BackingType);
+
+                const offset_at_end = @bitSizeOf(BackingType) - @bitSizeOf(PackedType);
+                for ([_]usize{ 0, 1, 7, 8, 9, 10, 15, 16, 86, offset_at_end }) |offset| {
+                    if (offset > offset_at_end or offset == @bitSizeOf(BackingType))
+                        continue;
+
+                    for ([_]PackedType{
+                        ~@as(PackedType, 0), // all ones: -1 iN / maxInt uN
+                        @as(PackedType, 0), // all zeros: 0 iN / 0 uN
+                        @bitCast(PackedType, @as(iPackedType, math.maxInt(iPackedType))), // maxInt iN
+                        @bitCast(PackedType, @as(iPackedType, math.minInt(iPackedType))), // maxInt iN
+                        random.int(PackedType), // random
+                        random.int(PackedType), // random
+                    }) |write_value| {
+                        { // Fixed-size Read/Write (Native-endian)
+
+                            // Initialize Value
+                            var value: BackingType = init_value;
+
+                            // Read
+                            const read_value1 = readPackedInt(PackedType, asBytes(&value), offset, native_endian);
+                            try expect(read_value1 == @bitCast(PackedType, @truncate(uPackedType, value >> @intCast(Log2T, offset))));
+
+                            // Write
+                            writePackedInt(PackedType, asBytes(&value), offset, write_value, native_endian);
+                            try expect(write_value == @bitCast(PackedType, @truncate(uPackedType, value >> @intCast(Log2T, offset))));
+
+                            // Read again
+                            const read_value2 = readPackedInt(PackedType, asBytes(&value), offset, native_endian);
+                            try expect(read_value2 == write_value);
+
+                            // Verify bits outside of the target integer are unmodified
+                            const diff_bits = init_value ^ value;
+                            if (offset != offset_at_end)
+                                try expect(diff_bits >> @intCast(Log2T, offset + @bitSizeOf(PackedType)) == 0);
+                            if (offset != 0)
+                                try expect(diff_bits << @intCast(Log2T, @bitSizeOf(BackingType) - offset) == 0);
+                        }
+
+                        { // Fixed-size Read/Write (Foreign-endian)
+
+                            // Initialize Value
+                            var value: BackingType = @byteSwap(init_value);
+
+                            // Read
+                            const read_value1 = readPackedInt(PackedType, asBytes(&value), offset, foreign_endian);
+                            try expect(read_value1 == @bitCast(PackedType, @truncate(uPackedType, @byteSwap(value) >> @intCast(Log2T, offset))));
+
+                            // Write
+                            writePackedInt(PackedType, asBytes(&value), offset, write_value, foreign_endian);
+                            try expect(write_value == @bitCast(PackedType, @truncate(uPackedType, @byteSwap(value) >> @intCast(Log2T, offset))));
+
+                            // Read again
+                            const read_value2 = readPackedInt(PackedType, asBytes(&value), offset, foreign_endian);
+                            try expect(read_value2 == write_value);
+
+                            // Verify bits outside of the target integer are unmodified
+                            const diff_bits = init_value ^ @byteSwap(value);
+                            if (offset != offset_at_end)
+                                try expect(diff_bits >> @intCast(Log2T, offset + @bitSizeOf(PackedType)) == 0);
+                            if (offset != 0)
+                                try expect(diff_bits << @intCast(Log2T, @bitSizeOf(BackingType) - offset) == 0);
+                        }
+
+                        const signedness = @typeInfo(PackedType).Int.signedness;
+                        const NextPowerOfTwoInt = std.meta.Int(signedness, comptime try std.math.ceilPowerOfTwo(u16, @bitSizeOf(PackedType)));
+                        const ui64 = std.meta.Int(signedness, 64);
+                        inline for ([_]type{ PackedType, NextPowerOfTwoInt, ui64 }) |U| {
+                            { // Variable-size Read/Write (Native-endian)
+
+                                if (@bitSizeOf(U) < @bitSizeOf(PackedType))
+                                    continue;
+
+                                // Initialize Value
+                                var value: BackingType = init_value;
+
+                                // Read
+                                const read_value1 = readVarPackedInt(U, asBytes(&value), offset, @bitSizeOf(PackedType), native_endian, signedness);
+                                try expect(read_value1 == @bitCast(PackedType, @truncate(uPackedType, value >> @intCast(Log2T, offset))));
+
+                                // Write
+                                writeVarPackedInt(asBytes(&value), offset, @bitSizeOf(PackedType), @as(U, write_value), native_endian);
+                                try expect(write_value == @bitCast(PackedType, @truncate(uPackedType, value >> @intCast(Log2T, offset))));
+
+                                // Read again
+                                const read_value2 = readVarPackedInt(U, asBytes(&value), offset, @bitSizeOf(PackedType), native_endian, signedness);
+                                try expect(read_value2 == write_value);
+
+                                // Verify bits outside of the target integer are unmodified
+                                const diff_bits = init_value ^ value;
+                                if (offset != offset_at_end)
+                                    try expect(diff_bits >> @intCast(Log2T, offset + @bitSizeOf(PackedType)) == 0);
+                                if (offset != 0)
+                                    try expect(diff_bits << @intCast(Log2T, @bitSizeOf(BackingType) - offset) == 0);
+                            }
+
+                            { // Variable-size Read/Write (Foreign-endian)
+
+                                if (@bitSizeOf(U) < @bitSizeOf(PackedType))
+                                    continue;
+
+                                // Initialize Value
+                                var value: BackingType = @byteSwap(init_value);
+
+                                // Read
+                                const read_value1 = readVarPackedInt(U, asBytes(&value), offset, @bitSizeOf(PackedType), foreign_endian, signedness);
+                                try expect(read_value1 == @bitCast(PackedType, @truncate(uPackedType, @byteSwap(value) >> @intCast(Log2T, offset))));
+
+                                // Write
+                                writeVarPackedInt(asBytes(&value), offset, @bitSizeOf(PackedType), @as(U, write_value), foreign_endian);
+                                try expect(write_value == @bitCast(PackedType, @truncate(uPackedType, @byteSwap(value) >> @intCast(Log2T, offset))));
+
+                                // Read again
+                                const read_value2 = readVarPackedInt(U, asBytes(&value), offset, @bitSizeOf(PackedType), foreign_endian, signedness);
+                                try expect(read_value2 == write_value);
+
+                                // Verify bits outside of the target integer are unmodified
+                                const diff_bits = init_value ^ @byteSwap(value);
+                                if (offset != offset_at_end)
+                                    try expect(diff_bits >> @intCast(Log2T, offset + @bitSizeOf(PackedType)) == 0);
+                                if (offset != 0)
+                                    try expect(diff_bits << @intCast(Log2T, @bitSizeOf(BackingType) - offset) == 0);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

From 3295fee9116789f144e6406493116c451aee7c57 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Tue, 18 Oct 2022 11:37:43 -0700
Subject: [PATCH 59/70] stage2: Use mem.readPackedInt etc. for packed bitcasts

Packed memory has a well-defined layout that doesn't require
conversion from an integer to read from. Let's use it :-)

This change means that for bitcasting to/from a packed value that
is N layers deep, we no longer have to create N temporary big-ints
and perform N copies.

Other miscellaneous improvements:
  - Adds support for casting to packed enums and vectors
  - Fixes bitcasting to/from vectors outside of a packed struct
  - Adds a fast path for bitcasting <= u/i64
  - Fixes bug when bitcasting f80 which would clear following fields

This also changes the bitcast memory layout of exotic integers on
big-endian systems to match what's empirically observed on our targets.
Technically, this layout is not guaranteed by LLVM so we should probably
ban bitcasts that reveal these padding bits, but for now this is an
improvement.
---
 lib/std/math/big/int.zig      | 161 +++++------
 lib/std/math/big/int_test.zig | 102 ++++---
 src/Sema.zig                  |  42 ---
 src/codegen.zig               |   2 +-
 src/value.zig                 | 497 +++++++++++++++++-----------------
 test/behavior/bitcast.zig     |  87 +++++-
 6 files changed, 465 insertions(+), 426 deletions(-)

diff --git a/lib/std/math/big/int.zig b/lib/std/math/big/int.zig
index b875f73b2e..ac2f089ea1 100644
--- a/lib/std/math/big/int.zig
+++ b/lib/std/math/big/int.zig
@@ -1762,16 +1762,32 @@ pub const Mutable = struct {
     }
 
     /// Read the value of `x` from `buffer`
-    /// Asserts that `buffer`, `abi_size`, and `bit_count` are large enough to store the value.
+    /// Asserts that `buffer` is large enough to contain a value of bit-size `bit_count`.
     ///
     /// The contents of `buffer` are interpreted as if they were the contents of
-    /// @ptrCast(*[abi_size]const u8, &x). Byte ordering is determined by `endian`
+    /// @ptrCast(*[buffer.len]const u8, &x). Byte ordering is determined by `endian`
     /// and any required padding bits are expected on the MSB end.
     pub fn readTwosComplement(
         x: *Mutable,
         buffer: []const u8,
         bit_count: usize,
-        abi_size: usize,
+        endian: Endian,
+        signedness: Signedness,
+    ) void {
+        return readPackedTwosComplement(x, buffer, 0, bit_count, endian, signedness);
+    }
+
+    /// Read the value of `x` from a packed memory `buffer`.
+    /// Asserts that `buffer` is large enough to contain a value of bit-size `bit_count`
+    /// at offset `bit_offset`.
+    ///
+    /// This is equivalent to loading the value of an integer with `bit_count` bits as
+    /// if it were a field in packed memory at the provided bit offset.
+    pub fn readPackedTwosComplement(
+        x: *Mutable,
+        bytes: []const u8,
+        bit_offset: usize,
+        bit_count: usize,
         endian: Endian,
         signedness: Signedness,
     ) void {
@@ -1782,75 +1798,54 @@ pub const Mutable = struct {
             return;
         }
 
-        // byte_count is our total read size: it cannot exceed abi_size,
-        // but may be less as long as it includes the required bits
-        const limb_count = calcTwosCompLimbCount(bit_count);
-        const byte_count = std.math.min(abi_size, @sizeOf(Limb) * limb_count);
-        assert(8 * byte_count >= bit_count);
-
         // Check whether the input is negative
         var positive = true;
         if (signedness == .signed) {
+            const total_bits = bit_offset + bit_count;
             var last_byte = switch (endian) {
-                .Little => ((bit_count + 7) / 8) - 1,
-                .Big => abi_size - ((bit_count + 7) / 8),
+                .Little => ((total_bits + 7) / 8) - 1,
+                .Big => bytes.len - ((total_bits + 7) / 8),
             };
 
-            const sign_bit = @as(u8, 1) << @intCast(u3, (bit_count - 1) % 8);
-            positive = ((buffer[last_byte] & sign_bit) == 0);
+            const sign_bit = @as(u8, 1) << @intCast(u3, (total_bits - 1) % 8);
+            positive = ((bytes[last_byte] & sign_bit) == 0);
         }
 
         // Copy all complete limbs
-        var carry: u1 = if (positive) 0 else 1;
+        var carry: u1 = 1;
         var limb_index: usize = 0;
+        var bit_index: usize = 0;
         while (limb_index < bit_count / @bitSizeOf(Limb)) : (limb_index += 1) {
-            var buf_index = switch (endian) {
-                .Little => @sizeOf(Limb) * limb_index,
-                .Big => abi_size - (limb_index + 1) * @sizeOf(Limb),
-            };
-
-            const limb_buf = @ptrCast(*const [@sizeOf(Limb)]u8, buffer[buf_index..]);
-            var limb = mem.readInt(Limb, limb_buf, endian);
+            // Read one Limb of bits
+            var limb = mem.readPackedInt(Limb, bytes, bit_index + bit_offset, endian);
+            bit_index += @bitSizeOf(Limb);
 
             // 2's complement (bitwise not, then add carry bit)
             if (!positive) carry = @boolToInt(@addWithOverflow(Limb, ~limb, carry, &limb));
             x.limbs[limb_index] = limb;
         }
 
-        // Copy the remaining N bytes (N <= @sizeOf(Limb))
-        var bytes_read = limb_index * @sizeOf(Limb);
-        if (bytes_read != byte_count) {
-            var limb: Limb = 0;
-
-            while (bytes_read != byte_count) {
-                const read_size = std.math.floorPowerOfTwo(usize, byte_count - bytes_read);
-                var int_buffer = switch (endian) {
-                    .Little => buffer[bytes_read..],
-                    .Big => buffer[(abi_size - bytes_read - read_size)..],
-                };
-                limb |= @intCast(Limb, switch (read_size) {
-                    1 => mem.readInt(u8, int_buffer[0..1], endian),
-                    2 => mem.readInt(u16, int_buffer[0..2], endian),
-                    4 => mem.readInt(u32, int_buffer[0..4], endian),
-                    8 => mem.readInt(u64, int_buffer[0..8], endian),
-                    16 => mem.readInt(u128, int_buffer[0..16], endian),
-                    else => unreachable,
-                }) << @intCast(Log2Limb, 8 * (bytes_read % @sizeOf(Limb)));
-                bytes_read += read_size;
-            }
+        // Copy the remaining bits
+        if (bit_count != bit_index) {
+            // Read all remaining bits
+            var limb = switch (signedness) {
+                .unsigned => mem.readVarPackedInt(Limb, bytes, bit_index + bit_offset, bit_count - bit_index, endian, .unsigned),
+                .signed => b: {
+                    const SLimb = std.meta.Int(.signed, @bitSizeOf(Limb));
+                    const limb = mem.readVarPackedInt(SLimb, bytes, bit_index + bit_offset, bit_count - bit_index, endian, .signed);
+                    break :b @bitCast(Limb, limb);
+                },
+            };
 
             // 2's complement (bitwise not, then add carry bit)
-            if (!positive) _ = @addWithOverflow(Limb, ~limb, carry, &limb);
+            if (!positive) assert(!@addWithOverflow(Limb, ~limb, carry, &limb));
+            x.limbs[limb_index] = limb;
 
-            // Mask off any unused bits
-            const valid_bits = @intCast(Log2Limb, bit_count % @bitSizeOf(Limb));
-            const mask = (@as(Limb, 1) << valid_bits) -% 1; // 0b0..01..1 with (valid_bits_in_limb) trailing ones
-            limb &= mask;
-
-            x.limbs[limb_count - 1] = limb;
+            limb_index += 1;
         }
+
         x.positive = positive;
-        x.len = limb_count;
+        x.len = limb_index;
         x.normalize(x.len);
     }
 
@@ -2212,66 +2207,48 @@ pub const Const = struct {
     }
 
     /// Write the value of `x` into `buffer`
-    /// Asserts that `buffer`, `abi_size`, and `bit_count` are large enough to store the value.
+    /// Asserts that `buffer` is large enough to store the value.
     ///
     /// `buffer` is filled so that its contents match what would be observed via
-    /// @ptrCast(*[abi_size]const u8, &x). Byte ordering is determined by `endian`,
+    /// @ptrCast(*[buffer.len]const u8, &x). Byte ordering is determined by `endian`,
     /// and any required padding bits are added on the MSB end.
-    pub fn writeTwosComplement(x: Const, buffer: []u8, bit_count: usize, abi_size: usize, endian: Endian) void {
+    pub fn writeTwosComplement(x: Const, buffer: []u8, endian: Endian) void {
+        return writePackedTwosComplement(x, buffer, 0, 8 * buffer.len, endian);
+    }
 
-        // byte_count is our total write size
-        const byte_count = abi_size;
-        assert(8 * byte_count >= bit_count);
-        assert(buffer.len >= byte_count);
+    /// Write the value of `x` to a packed memory `buffer`.
+    /// Asserts that `buffer` is large enough to contain a value of bit-size `bit_count`
+    /// at offset `bit_offset`.
+    ///
+    /// This is equivalent to storing the value of an integer with `bit_count` bits as
+    /// if it were a field in packed memory at the provided bit offset.
+    pub fn writePackedTwosComplement(x: Const, bytes: []u8, bit_offset: usize, bit_count: usize, endian: Endian) void {
         assert(x.fitsInTwosComp(if (x.positive) .unsigned else .signed, bit_count));
 
         // Copy all complete limbs
-        var carry: u1 = if (x.positive) 0 else 1;
+        var carry: u1 = 1;
         var limb_index: usize = 0;
-        while (limb_index < byte_count / @sizeOf(Limb)) : (limb_index += 1) {
-            var buf_index = switch (endian) {
-                .Little => @sizeOf(Limb) * limb_index,
-                .Big => abi_size - (limb_index + 1) * @sizeOf(Limb),
-            };
-
+        var bit_index: usize = 0;
+        while (limb_index < bit_count / @bitSizeOf(Limb)) : (limb_index += 1) {
             var limb: Limb = if (limb_index < x.limbs.len) x.limbs[limb_index] else 0;
+
             // 2's complement (bitwise not, then add carry bit)
             if (!x.positive) carry = @boolToInt(@addWithOverflow(Limb, ~limb, carry, &limb));
 
-            var limb_buf = @ptrCast(*[@sizeOf(Limb)]u8, buffer[buf_index..]);
-            mem.writeInt(Limb, limb_buf, limb, endian);
+            // Write one Limb of bits
+            mem.writePackedInt(Limb, bytes, bit_index + bit_offset, limb, endian);
+            bit_index += @bitSizeOf(Limb);
         }
 
-        // Copy the remaining N bytes (N < @sizeOf(Limb))
-        var bytes_written = limb_index * @sizeOf(Limb);
-        if (bytes_written != byte_count) {
+        // Copy the remaining bits
+        if (bit_count != bit_index) {
             var limb: Limb = if (limb_index < x.limbs.len) x.limbs[limb_index] else 0;
+
             // 2's complement (bitwise not, then add carry bit)
             if (!x.positive) _ = @addWithOverflow(Limb, ~limb, carry, &limb);
 
-            while (bytes_written != byte_count) {
-                const write_size = std.math.floorPowerOfTwo(usize, byte_count - bytes_written);
-                var int_buffer = switch (endian) {
-                    .Little => buffer[bytes_written..],
-                    .Big => buffer[(abi_size - bytes_written - write_size)..],
-                };
-
-                if (write_size == 1) {
-                    mem.writeInt(u8, int_buffer[0..1], @truncate(u8, limb), endian);
-                } else if (@sizeOf(Limb) >= 2 and write_size == 2) {
-                    mem.writeInt(u16, int_buffer[0..2], @truncate(u16, limb), endian);
-                } else if (@sizeOf(Limb) >= 4 and write_size == 4) {
-                    mem.writeInt(u32, int_buffer[0..4], @truncate(u32, limb), endian);
-                } else if (@sizeOf(Limb) >= 8 and write_size == 8) {
-                    mem.writeInt(u64, int_buffer[0..8], @truncate(u64, limb), endian);
-                } else if (@sizeOf(Limb) >= 16 and write_size == 16) {
-                    mem.writeInt(u128, int_buffer[0..16], @truncate(u128, limb), endian);
-                } else if (@sizeOf(Limb) >= 32) {
-                    @compileError("@sizeOf(Limb) exceeded supported range");
-                } else unreachable;
-                limb >>= @intCast(Log2Limb, 8 * write_size);
-                bytes_written += write_size;
-            }
+            // Write all remaining bits
+            mem.writeVarPackedInt(bytes, bit_index + bit_offset, bit_count - bit_index, limb, endian);
         }
     }
 
diff --git a/lib/std/math/big/int_test.zig b/lib/std/math/big/int_test.zig
index 5685a38d41..97de06bfcc 100644
--- a/lib/std/math/big/int_test.zig
+++ b/lib/std/math/big/int_test.zig
@@ -2603,13 +2603,13 @@ test "big int conversion read/write twos complement" {
 
     for (endians) |endian| {
         // Writing to buffer and back should not change anything
-        a.toConst().writeTwosComplement(buffer1, 493, abi_size, endian);
-        m.readTwosComplement(buffer1, 493, abi_size, endian, .unsigned);
+        a.toConst().writeTwosComplement(buffer1[0..abi_size], endian);
+        m.readTwosComplement(buffer1[0..abi_size], 493, endian, .unsigned);
         try testing.expect(m.toConst().order(a.toConst()) == .eq);
 
         // Equivalent to @bitCast(i493, @as(u493, intMax(u493))
-        a.toConst().writeTwosComplement(buffer1, 493, abi_size, endian);
-        m.readTwosComplement(buffer1, 493, abi_size, endian, .signed);
+        a.toConst().writeTwosComplement(buffer1[0..abi_size], endian);
+        m.readTwosComplement(buffer1[0..abi_size], 493, endian, .signed);
         try testing.expect(m.toConst().orderAgainstScalar(-1) == .eq);
     }
 }
@@ -2628,26 +2628,26 @@ test "big int conversion read twos complement with padding" {
     // (3) should sign-extend any bits from bit_count to 8 * abi_size
 
     var bit_count: usize = 12 * 8 + 1;
-    a.toConst().writeTwosComplement(buffer1, bit_count, 13, .Little);
+    a.toConst().writeTwosComplement(buffer1[0..13], .Little);
     try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0xaa, 0xaa, 0xaa }));
-    a.toConst().writeTwosComplement(buffer1, bit_count, 13, .Big);
+    a.toConst().writeTwosComplement(buffer1[0..13], .Big);
     try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xaa, 0xaa, 0xaa }));
-    a.toConst().writeTwosComplement(buffer1, bit_count, 16, .Little);
+    a.toConst().writeTwosComplement(buffer1[0..16], .Little);
     try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0, 0x0, 0x0 }));
-    a.toConst().writeTwosComplement(buffer1, bit_count, 16, .Big);
+    a.toConst().writeTwosComplement(buffer1[0..16], .Big);
     try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0x0, 0x0, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd }));
 
     @memset(buffer1.ptr, 0xaa, buffer1.len);
     try a.set(-0x01_02030405_06070809_0a0b0c0d);
     bit_count = 12 * 8 + 2;
 
-    a.toConst().writeTwosComplement(buffer1, bit_count, 13, .Little);
+    a.toConst().writeTwosComplement(buffer1[0..13], .Little);
     try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0xf3, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xaa, 0xaa, 0xaa }));
-    a.toConst().writeTwosComplement(buffer1, bit_count, 13, .Big);
+    a.toConst().writeTwosComplement(buffer1[0..13], .Big);
     try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf3, 0xaa, 0xaa, 0xaa }));
-    a.toConst().writeTwosComplement(buffer1, bit_count, 16, .Little);
+    a.toConst().writeTwosComplement(buffer1[0..16], .Little);
     try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0xf3, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0xff, 0xff }));
-    a.toConst().writeTwosComplement(buffer1, bit_count, 16, .Big);
+    a.toConst().writeTwosComplement(buffer1[0..16], .Big);
     try testing.expect(std.mem.eql(u8, buffer1, &[_]u8{ 0xff, 0xff, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf3 }));
 }
 
@@ -2660,17 +2660,15 @@ test "big int write twos complement +/- zero" {
     defer testing.allocator.free(buffer1);
     @memset(buffer1.ptr, 0xaa, buffer1.len);
 
-    var bit_count: usize = 0;
-
     // Test zero
 
-    m.toConst().writeTwosComplement(buffer1, bit_count, 13, .Little);
+    m.toConst().writeTwosComplement(buffer1[0..13], .Little);
     try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 13) ++ ([_]u8{0xaa} ** 3))));
-    m.toConst().writeTwosComplement(buffer1, bit_count, 13, .Big);
+    m.toConst().writeTwosComplement(buffer1[0..13], .Big);
     try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 13) ++ ([_]u8{0xaa} ** 3))));
-    m.toConst().writeTwosComplement(buffer1, bit_count, 16, .Little);
+    m.toConst().writeTwosComplement(buffer1[0..16], .Little);
     try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 16))));
-    m.toConst().writeTwosComplement(buffer1, bit_count, 16, .Big);
+    m.toConst().writeTwosComplement(buffer1[0..16], .Big);
     try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 16))));
 
     @memset(buffer1.ptr, 0xaa, buffer1.len);
@@ -2678,13 +2676,13 @@ test "big int write twos complement +/- zero" {
 
     // Test negative zero
 
-    m.toConst().writeTwosComplement(buffer1, bit_count, 13, .Little);
+    m.toConst().writeTwosComplement(buffer1[0..13], .Little);
     try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 13) ++ ([_]u8{0xaa} ** 3))));
-    m.toConst().writeTwosComplement(buffer1, bit_count, 13, .Big);
+    m.toConst().writeTwosComplement(buffer1[0..13], .Big);
     try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 13) ++ ([_]u8{0xaa} ** 3))));
-    m.toConst().writeTwosComplement(buffer1, bit_count, 16, .Little);
+    m.toConst().writeTwosComplement(buffer1[0..16], .Little);
     try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 16))));
-    m.toConst().writeTwosComplement(buffer1, bit_count, 16, .Big);
+    m.toConst().writeTwosComplement(buffer1[0..16], .Big);
     try testing.expect(std.mem.eql(u8, buffer1, &(([_]u8{0} ** 16))));
 }
 
@@ -2705,62 +2703,82 @@ test "big int conversion write twos complement with padding" {
     // Test 0x01_02030405_06070809_0a0b0c0d
 
     buffer = &[_]u8{ 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0xb };
-    m.readTwosComplement(buffer, bit_count, 13, .Little, .unsigned);
+    m.readTwosComplement(buffer[0..13], bit_count, .Little, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x01_02030405_06070809_0a0b0c0d) == .eq);
 
     buffer = &[_]u8{ 0xb, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd };
-    m.readTwosComplement(buffer, bit_count, 13, .Big, .unsigned);
+    m.readTwosComplement(buffer[0..13], bit_count, .Big, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x01_02030405_06070809_0a0b0c0d) == .eq);
 
     buffer = &[_]u8{ 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0xab, 0xaa, 0xaa, 0xaa };
-    m.readTwosComplement(buffer, bit_count, 16, .Little, .unsigned);
+    m.readTwosComplement(buffer[0..16], bit_count, .Little, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x01_02030405_06070809_0a0b0c0d) == .eq);
 
     buffer = &[_]u8{ 0xaa, 0xaa, 0xaa, 0xab, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd };
-    m.readTwosComplement(buffer, bit_count, 16, .Big, .unsigned);
+    m.readTwosComplement(buffer[0..16], bit_count, .Big, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x01_02030405_06070809_0a0b0c0d) == .eq);
 
+    bit_count = @sizeOf(Limb) * 8;
+
+    // Test 0x0a0a0a0a_02030405_06070809_0a0b0c0d
+
+    buffer = &[_]u8{ 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0xaa };
+    m.readTwosComplement(buffer[0..13], bit_count, .Little, .unsigned);
+    try testing.expect(m.toConst().orderAgainstScalar(@truncate(Limb, 0xaa_02030405_06070809_0a0b0c0d)) == .eq);
+
+    buffer = &[_]u8{ 0xaa, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd };
+    m.readTwosComplement(buffer[0..13], bit_count, .Big, .unsigned);
+    try testing.expect(m.toConst().orderAgainstScalar(@truncate(Limb, 0xaa_02030405_06070809_0a0b0c0d)) == .eq);
+
+    buffer = &[_]u8{ 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0xaa, 0xaa, 0xaa, 0xaa };
+    m.readTwosComplement(buffer[0..16], bit_count, .Little, .unsigned);
+    try testing.expect(m.toConst().orderAgainstScalar(@truncate(Limb, 0xaaaaaaaa_02030405_06070809_0a0b0c0d)) == .eq);
+
+    buffer = &[_]u8{ 0xaa, 0xaa, 0xaa, 0xaa, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd };
+    m.readTwosComplement(buffer[0..16], bit_count, .Big, .unsigned);
+    try testing.expect(m.toConst().orderAgainstScalar(@truncate(Limb, 0xaaaaaaaa_02030405_06070809_0a0b0c0d)) == .eq);
+
     bit_count = 12 * 8 + 2;
 
     // Test -0x01_02030405_06070809_0a0b0c0d
 
     buffer = &[_]u8{ 0xf3, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0x02 };
-    m.readTwosComplement(buffer, bit_count, 13, .Little, .signed);
+    m.readTwosComplement(buffer[0..13], bit_count, .Little, .signed);
     try testing.expect(m.toConst().orderAgainstScalar(-0x01_02030405_06070809_0a0b0c0d) == .eq);
 
     buffer = &[_]u8{ 0x02, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf3 };
-    m.readTwosComplement(buffer, bit_count, 13, .Big, .signed);
+    m.readTwosComplement(buffer[0..13], bit_count, .Big, .signed);
     try testing.expect(m.toConst().orderAgainstScalar(-0x01_02030405_06070809_0a0b0c0d) == .eq);
 
     buffer = &[_]u8{ 0xf3, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0x02, 0xaa, 0xaa, 0xaa };
-    m.readTwosComplement(buffer, bit_count, 16, .Little, .signed);
+    m.readTwosComplement(buffer[0..16], bit_count, .Little, .signed);
     try testing.expect(m.toConst().orderAgainstScalar(-0x01_02030405_06070809_0a0b0c0d) == .eq);
 
     buffer = &[_]u8{ 0xaa, 0xaa, 0xaa, 0x02, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf3 };
-    m.readTwosComplement(buffer, bit_count, 16, .Big, .signed);
+    m.readTwosComplement(buffer[0..16], bit_count, .Big, .signed);
     try testing.expect(m.toConst().orderAgainstScalar(-0x01_02030405_06070809_0a0b0c0d) == .eq);
 
     // Test 0
 
     buffer = &([_]u8{0} ** 16);
-    m.readTwosComplement(buffer, bit_count, 13, .Little, .unsigned);
+    m.readTwosComplement(buffer[0..13], bit_count, .Little, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);
-    m.readTwosComplement(buffer, bit_count, 13, .Big, .unsigned);
+    m.readTwosComplement(buffer[0..13], bit_count, .Big, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);
-    m.readTwosComplement(buffer, bit_count, 16, .Little, .unsigned);
+    m.readTwosComplement(buffer[0..16], bit_count, .Little, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);
-    m.readTwosComplement(buffer, bit_count, 16, .Big, .unsigned);
+    m.readTwosComplement(buffer[0..16], bit_count, .Big, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);
 
     bit_count = 0;
     buffer = &([_]u8{0xaa} ** 16);
-    m.readTwosComplement(buffer, bit_count, 13, .Little, .unsigned);
+    m.readTwosComplement(buffer[0..13], bit_count, .Little, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);
-    m.readTwosComplement(buffer, bit_count, 13, .Big, .unsigned);
+    m.readTwosComplement(buffer[0..13], bit_count, .Big, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);
-    m.readTwosComplement(buffer, bit_count, 16, .Little, .unsigned);
+    m.readTwosComplement(buffer[0..16], bit_count, .Little, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);
-    m.readTwosComplement(buffer, bit_count, 16, .Big, .unsigned);
+    m.readTwosComplement(buffer[0..16], bit_count, .Big, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);
 }
 
@@ -2779,15 +2797,15 @@ test "big int conversion write twos complement zero" {
     var buffer: []const u8 = undefined;
 
     buffer = &([_]u8{0} ** 13);
-    m.readTwosComplement(buffer, bit_count, 13, .Little, .unsigned);
+    m.readTwosComplement(buffer[0..13], bit_count, .Little, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);
-    m.readTwosComplement(buffer, bit_count, 13, .Big, .unsigned);
+    m.readTwosComplement(buffer[0..13], bit_count, .Big, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);
 
     buffer = &([_]u8{0} ** 16);
-    m.readTwosComplement(buffer, bit_count, 16, .Little, .unsigned);
+    m.readTwosComplement(buffer[0..16], bit_count, .Little, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);
-    m.readTwosComplement(buffer, bit_count, 16, .Big, .unsigned);
+    m.readTwosComplement(buffer[0..16], bit_count, .Big, .unsigned);
     try testing.expect(m.toConst().orderAgainstScalar(0x0) == .eq);
 }
 
diff --git a/src/Sema.zig b/src/Sema.zig
index 9f425b7bcf..fbc8d1dd8e 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -26445,48 +26445,6 @@ fn bitCastVal(
     const target = sema.mod.getTarget();
     if (old_ty.eql(new_ty, sema.mod)) return val;
 
-    // Some conversions have a bitwise definition that ignores in-memory layout,
-    // such as converting between f80 and u80.
-
-    if (old_ty.eql(Type.f80, sema.mod) and new_ty.isAbiInt()) {
-        const float = val.toFloat(f80);
-        switch (new_ty.intInfo(target).signedness) {
-            .signed => {
-                const int = @bitCast(i80, float);
-                const limbs = try sema.arena.alloc(std.math.big.Limb, 2);
-                const big_int = std.math.big.int.Mutable.init(limbs, int);
-                return Value.fromBigInt(sema.arena, big_int.toConst());
-            },
-            .unsigned => {
-                const int = @bitCast(u80, float);
-                const limbs = try sema.arena.alloc(std.math.big.Limb, 2);
-                const big_int = std.math.big.int.Mutable.init(limbs, int);
-                return Value.fromBigInt(sema.arena, big_int.toConst());
-            },
-        }
-    }
-
-    if (new_ty.eql(Type.f80, sema.mod) and old_ty.isAbiInt()) {
-        var bigint_space: Value.BigIntSpace = undefined;
-        var bigint = try val.toBigIntAdvanced(&bigint_space, target, sema.kit(block, src));
-        switch (old_ty.intInfo(target).signedness) {
-            .signed => {
-                // This conversion cannot fail because we already checked bit size before
-                // calling bitCastVal.
-                const int = bigint.to(i80) catch unreachable;
-                const float = @bitCast(f80, int);
-                return Value.Tag.float_80.create(sema.arena, float);
-            },
-            .unsigned => {
-                // This conversion cannot fail because we already checked bit size before
-                // calling bitCastVal.
-                const int = bigint.to(u80) catch unreachable;
-                const float = @bitCast(f80, int);
-                return Value.Tag.float_80.create(sema.arena, float);
-            },
-        }
-    }
-
     // For types with well-defined memory layouts, we serialize them a byte buffer,
     // then deserialize to the new type.
     const abi_size = try sema.usizeCast(block, src, old_ty.abiSize(target));
diff --git a/src/codegen.zig b/src/codegen.zig
index 757bd23b38..6acea5a509 100644
--- a/src/codegen.zig
+++ b/src/codegen.zig
@@ -470,7 +470,7 @@ pub fn generateSymbol(
                 const abi_size = math.cast(usize, typed_value.ty.abiSize(target)) orelse return error.Overflow;
                 const start = code.items.len;
                 try code.resize(start + abi_size);
-                bigint.writeTwosComplement(code.items[start..][0..abi_size], info.bits, abi_size, endian);
+                bigint.writeTwosComplement(code.items[start..][0..abi_size], endian);
                 return Result{ .appended = {} };
             }
             switch (info.signedness) {
diff --git a/src/value.zig b/src/value.zig
index 28601c1723..7468a69fda 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -1206,8 +1206,13 @@ pub const Value = extern union {
         };
     }
 
+    /// Write a Value's contents to `buffer`.
+    ///
+    /// Asserts that buffer.len >= ty.abiSize(). The buffer is allowed to extend past
+    /// the end of the value in memory.
     pub fn writeToMemory(val: Value, ty: Type, mod: *Module, buffer: []u8) void {
         const target = mod.getTarget();
+        const endian = target.cpu.arch.endian();
         if (val.isUndef()) {
             const size = @intCast(usize, ty.abiSize(target));
             std.mem.set(u8, buffer[0..size], 0xaa);
@@ -1218,31 +1223,41 @@ pub const Value = extern union {
             .Bool => {
                 buffer[0] = @boolToInt(val.toBool());
             },
-            .Int => {
-                var bigint_buffer: BigIntSpace = undefined;
-                const bigint = val.toBigInt(&bigint_buffer, target);
-                const bits = ty.intInfo(target).bits;
-                const abi_size = @intCast(usize, ty.abiSize(target));
-                bigint.writeTwosComplement(buffer, bits, abi_size, target.cpu.arch.endian());
-            },
-            .Enum => {
+            .Int, .Enum => {
+                const int_info = ty.intInfo(target);
+                const bits = int_info.bits;
+                const byte_count = (bits + 7) / 8;
+
                 var enum_buffer: Payload.U64 = undefined;
                 const int_val = val.enumToInt(ty, &enum_buffer);
-                var bigint_buffer: BigIntSpace = undefined;
-                const bigint = int_val.toBigInt(&bigint_buffer, target);
-                const bits = ty.intInfo(target).bits;
-                const abi_size = @intCast(usize, ty.abiSize(target));
-                bigint.writeTwosComplement(buffer, bits, abi_size, target.cpu.arch.endian());
+
+                if (byte_count <= @sizeOf(u64)) {
+                    const int: u64 = switch (int_val.tag()) {
+                        .zero => 0,
+                        .one => 1,
+                        .int_u64 => int_val.castTag(.int_u64).?.data,
+                        .int_i64 => @bitCast(u64, int_val.castTag(.int_i64).?.data),
+                        else => unreachable,
+                    };
+                    for (buffer[0..byte_count]) |_, i| switch (endian) {
+                        .Little => buffer[i] = @truncate(u8, (int >> @intCast(u6, (8 * i)))),
+                        .Big => buffer[byte_count - i - 1] = @truncate(u8, (int >> @intCast(u6, (8 * i)))),
+                    };
+                } else {
+                    var bigint_buffer: BigIntSpace = undefined;
+                    const bigint = int_val.toBigInt(&bigint_buffer, target);
+                    bigint.writeTwosComplement(buffer[0..byte_count], endian);
+                }
             },
             .Float => switch (ty.floatBits(target)) {
-                16 => return floatWriteToMemory(f16, val.toFloat(f16), target, buffer),
-                32 => return floatWriteToMemory(f32, val.toFloat(f32), target, buffer),
-                64 => return floatWriteToMemory(f64, val.toFloat(f64), target, buffer),
-                80 => return floatWriteToMemory(f80, val.toFloat(f80), target, buffer),
-                128 => return floatWriteToMemory(f128, val.toFloat(f128), target, buffer),
+                16 => std.mem.writeInt(u16, buffer[0..2], @bitCast(u16, val.toFloat(f16)), endian),
+                32 => std.mem.writeInt(u32, buffer[0..4], @bitCast(u32, val.toFloat(f32)), endian),
+                64 => std.mem.writeInt(u64, buffer[0..8], @bitCast(u64, val.toFloat(f64)), endian),
+                80 => std.mem.writeInt(u80, buffer[0..10], @bitCast(u80, val.toFloat(f80)), endian),
+                128 => std.mem.writeInt(u128, buffer[0..16], @bitCast(u128, val.toFloat(f128)), endian),
                 else => unreachable,
             },
-            .Array, .Vector => {
+            .Array => {
                 const len = ty.arrayLen();
                 const elem_ty = ty.childType();
                 const elem_size = @intCast(usize, elem_ty.abiSize(target));
@@ -1251,10 +1266,16 @@ pub const Value = extern union {
                 var buf_off: usize = 0;
                 while (elem_i < len) : (elem_i += 1) {
                     const elem_val = val.elemValueBuffer(mod, elem_i, &elem_value_buf);
-                    writeToMemory(elem_val, elem_ty, mod, buffer[buf_off..]);
+                    elem_val.writeToMemory(elem_ty, mod, buffer[buf_off..]);
                     buf_off += elem_size;
                 }
             },
+            .Vector => {
+                // We use byte_count instead of abi_size here, so that any padding bytes
+                // follow the data bytes, on both big- and little-endian systems.
+                const byte_count = (@intCast(usize, ty.bitSize(target)) + 7) / 8;
+                writeToPackedMemory(val, ty, mod, buffer[0..byte_count], 0);
+            },
             .Struct => switch (ty.containerLayout()) {
                 .Auto => unreachable, // Sema is supposed to have emitted a compile error already
                 .Extern => {
@@ -1266,122 +1287,113 @@ pub const Value = extern union {
                     }
                 },
                 .Packed => {
-                    // TODO allocate enough heap space instead of using this buffer
-                    // on the stack.
-                    var buf: [16]std.math.big.Limb = undefined;
-                    const host_int = packedStructToInt(val, ty, target, &buf);
-                    const abi_size = @intCast(usize, ty.abiSize(target));
-                    const bit_size = @intCast(usize, ty.bitSize(target));
-                    host_int.writeTwosComplement(buffer, bit_size, abi_size, target.cpu.arch.endian());
+                    const byte_count = (@intCast(usize, ty.bitSize(target)) + 7) / 8;
+                    writeToPackedMemory(val, ty, mod, buffer[0..byte_count], 0);
                 },
             },
             .ErrorSet => {
                 // TODO revisit this when we have the concept of the error tag type
                 const Int = u16;
                 const int = mod.global_error_set.get(val.castTag(.@"error").?.data.name).?;
-                std.mem.writeInt(Int, buffer[0..@sizeOf(Int)], @intCast(Int, int), target.cpu.arch.endian());
+                std.mem.writeInt(Int, buffer[0..@sizeOf(Int)], @intCast(Int, int), endian);
             },
             else => @panic("TODO implement writeToMemory for more types"),
         }
     }
 
-    fn packedStructToInt(val: Value, ty: Type, target: Target, buf: []std.math.big.Limb) BigIntConst {
-        var bigint = BigIntMutable.init(buf, 0);
-        const fields = ty.structFields().values();
-        const field_vals = val.castTag(.aggregate).?.data;
-        var bits: u16 = 0;
-        // TODO allocate enough heap space instead of using this buffer
-        // on the stack.
-        var field_buf: [16]std.math.big.Limb = undefined;
-        var field_space: BigIntSpace = undefined;
-        var field_buf2: [16]std.math.big.Limb = undefined;
-        for (fields) |field, i| {
-            const field_val = field_vals[i];
-            const field_bigint_const = switch (field.ty.zigTypeTag()) {
-                .Void => continue,
-                .Float => floatToBigInt(field_val, field.ty, target, &field_buf),
-                .Int, .Bool => intOrBoolToBigInt(field_val, field.ty, target, &field_buf, &field_space),
-                .Struct => switch (field.ty.containerLayout()) {
-                    .Auto, .Extern => unreachable, // Sema should have error'd before this.
-                    .Packed => packedStructToInt(field_val, field.ty, target, &field_buf),
-                },
-                .Vector => vectorToBigInt(field_val, field.ty, target, &field_buf),
-                .Enum => enumToBigInt(field_val, field.ty, target, &field_space),
-                .Union => unreachable, // TODO: packed structs support packed unions
-                else => unreachable,
-            };
-            var field_bigint = BigIntMutable.init(&field_buf2, 0);
-            field_bigint.shiftLeft(field_bigint_const, bits);
-            bits += @intCast(u16, field.ty.bitSize(target));
-            bigint.bitOr(bigint.toConst(), field_bigint.toConst());
-        }
-        return bigint.toConst();
-    }
-
-    fn intOrBoolToBigInt(val: Value, ty: Type, target: Target, buf: []std.math.big.Limb, space: *BigIntSpace) BigIntConst {
-        const big_int_const = val.toBigInt(space, target);
-        if (big_int_const.positive) return big_int_const;
-
-        var big_int = BigIntMutable.init(buf, 0);
-        big_int.bitNotWrap(big_int_const.negate(), .unsigned, @intCast(u32, ty.bitSize(target)));
-        big_int.addScalar(big_int.toConst(), 1);
-        return big_int.toConst();
-    }
-
-    fn vectorToBigInt(val: Value, ty: Type, target: Target, buf: []std.math.big.Limb) BigIntConst {
+    /// Write a Value's contents to `buffer`.
+    ///
+    /// Both the start and the end of the provided buffer must be tight, since
+    /// big-endian packed memory layouts start at the end of the buffer.
+    pub fn writeToPackedMemory(val: Value, ty: Type, mod: *Module, buffer: []u8, bit_offset: usize) void {
+        const target = mod.getTarget();
         const endian = target.cpu.arch.endian();
-        var vec_bitint = BigIntMutable.init(buf, 0);
-        const vec_len = @intCast(usize, ty.arrayLen());
-        const elem_ty = ty.childType();
-        const elem_size = @intCast(usize, elem_ty.bitSize(target));
-
-        var elem_buf: [16]std.math.big.Limb = undefined;
-        var elem_space: BigIntSpace = undefined;
-        var elem_buf2: [16]std.math.big.Limb = undefined;
-
-        var elem_i: usize = 0;
-        while (elem_i < vec_len) : (elem_i += 1) {
-            const elem_i_target = if (endian == .Big) vec_len - elem_i - 1 else elem_i;
-            const elem_val = val.indexVectorlike(elem_i_target);
-            const elem_bigint_const = switch (elem_ty.zigTypeTag()) {
-                .Int, .Bool => intOrBoolToBigInt(elem_val, elem_ty, target, &elem_buf, &elem_space),
-                .Float => floatToBigInt(elem_val, elem_ty, target, &elem_buf),
-                .Pointer => unreachable, // TODO
-                else => unreachable, // Sema should not let this happen
-            };
-            var elem_bitint = BigIntMutable.init(&elem_buf2, 0);
-            elem_bitint.shiftLeft(elem_bigint_const, elem_size * elem_i);
-            vec_bitint.bitOr(vec_bitint.toConst(), elem_bitint.toConst());
+        if (val.isUndef()) {
+            const bit_size = @intCast(usize, ty.bitSize(target));
+            std.mem.writeVarPackedInt(buffer, bit_offset, bit_size, @as(u1, 0), endian);
+            return;
+        }
+        switch (ty.zigTypeTag()) {
+            .Void => {},
+            .Bool => {
+                const byte_index = switch (endian) {
+                    .Little => bit_offset / 8,
+                    .Big => buffer.len - bit_offset / 8 - 1,
+                };
+                if (val.toBool()) {
+                    buffer[byte_index] |= (@as(u8, 1) << @intCast(u3, bit_offset % 8));
+                } else {
+                    buffer[byte_index] &= ~(@as(u8, 1) << @intCast(u3, bit_offset % 8));
+                }
+            },
+            .Int, .Enum => {
+                const bits = ty.intInfo(target).bits;
+                const abi_size = @intCast(usize, ty.abiSize(target));
+
+                var enum_buffer: Payload.U64 = undefined;
+                const int_val = val.enumToInt(ty, &enum_buffer);
+
+                if (abi_size <= @sizeOf(u64)) {
+                    const int: u64 = switch (int_val.tag()) {
+                        .zero => 0,
+                        .one => 1,
+                        .int_u64 => int_val.castTag(.int_u64).?.data,
+                        .int_i64 => @bitCast(u64, int_val.castTag(.int_i64).?.data),
+                        else => unreachable,
+                    };
+                    std.mem.writeVarPackedInt(buffer, bit_offset, bits, int, endian);
+                } else {
+                    var bigint_buffer: BigIntSpace = undefined;
+                    const bigint = int_val.toBigInt(&bigint_buffer, target);
+                    bigint.writePackedTwosComplement(buffer, bit_offset, bits, endian);
+                }
+            },
+            .Float => switch (ty.floatBits(target)) {
+                16 => std.mem.writePackedInt(u16, buffer, bit_offset, @bitCast(u16, val.toFloat(f16)), endian),
+                32 => std.mem.writePackedInt(u32, buffer, bit_offset, @bitCast(u32, val.toFloat(f32)), endian),
+                64 => std.mem.writePackedInt(u64, buffer, bit_offset, @bitCast(u64, val.toFloat(f64)), endian),
+                80 => std.mem.writePackedInt(u80, buffer, bit_offset, @bitCast(u80, val.toFloat(f80)), endian),
+                128 => std.mem.writePackedInt(u128, buffer, bit_offset, @bitCast(u128, val.toFloat(f128)), endian),
+                else => unreachable,
+            },
+            .Vector => {
+                const len = ty.arrayLen();
+                const elem_ty = ty.childType();
+                const elem_bit_size = @intCast(u16, elem_ty.bitSize(target));
+
+                var bits: u16 = 0;
+                var elem_i: usize = 0;
+                var elem_value_buf: ElemValueBuffer = undefined;
+                while (elem_i < len) : (elem_i += 1) {
+                    // On big-endian systems, LLVM reverses the element order of vectors by default
+                    const tgt_elem_i = if (endian == .Big) len - elem_i - 1 else elem_i;
+                    const elem_val = val.elemValueBuffer(mod, tgt_elem_i, &elem_value_buf);
+                    elem_val.writeToPackedMemory(elem_ty, mod, buffer, bit_offset + bits);
+                    bits += elem_bit_size;
+                }
+            },
+            .Struct => switch (ty.containerLayout()) {
+                .Auto => unreachable, // Sema is supposed to have emitted a compile error already
+                .Extern => unreachable, // Handled in non-packed writeToMemory
+                .Packed => {
+                    var bits: u16 = 0;
+                    const fields = ty.structFields().values();
+                    const field_vals = val.castTag(.aggregate).?.data;
+                    for (fields) |field, i| {
+                        const field_bits = @intCast(u16, field.ty.bitSize(target));
+                        field_vals[i].writeToPackedMemory(field.ty, mod, buffer, bit_offset + bits);
+                        bits += field_bits;
+                    }
+                },
+            },
+            else => @panic("TODO implement writeToPackedMemory for more types"),
         }
-        return vec_bitint.toConst();
-    }
-
-    fn enumToBigInt(val: Value, ty: Type, target: Target, space: *BigIntSpace) BigIntConst {
-        var enum_buf: Payload.U64 = undefined;
-        const int_val = val.enumToInt(ty, &enum_buf);
-        return int_val.toBigInt(space, target);
-    }
-
-    fn floatToBigInt(val: Value, ty: Type, target: Target, buf: []std.math.big.Limb) BigIntConst {
-        return switch (ty.floatBits(target)) {
-            16 => bitcastFloatToBigInt(f16, val.toFloat(f16), buf),
-            32 => bitcastFloatToBigInt(f32, val.toFloat(f32), buf),
-            64 => bitcastFloatToBigInt(f64, val.toFloat(f64), buf),
-            80 => bitcastFloatToBigInt(f80, val.toFloat(f80), buf),
-            128 => bitcastFloatToBigInt(f128, val.toFloat(f128), buf),
-            else => unreachable,
-        };
-    }
-
-    fn bitcastFloatToBigInt(comptime F: type, f: F, buf: []std.math.big.Limb) BigIntConst {
-        const Int = @Type(.{ .Int = .{
-            .signedness = .unsigned,
-            .bits = @typeInfo(F).Float.bits,
-        } });
-        const int = @bitCast(Int, f);
-        return BigIntMutable.init(buf, int).toConst();
     }
 
+    /// Load a Value from the contents of `buffer`.
+    ///
+    /// Asserts that buffer.len >= ty.abiSize(). The buffer is allowed to extend past
+    /// the end of the value in memory.
     pub fn readFromMemory(
         ty: Type,
         mod: *Module,
@@ -1389,6 +1401,7 @@ pub const Value = extern union {
         arena: Allocator,
     ) Allocator.Error!Value {
         const target = mod.getTarget();
+        const endian = target.cpu.arch.endian();
         switch (ty.zigTypeTag()) {
             .Void => return Value.@"void",
             .Bool => {
@@ -1398,27 +1411,40 @@ pub const Value = extern union {
                     return Value.@"true";
                 }
             },
-            .Int => {
-                if (buffer.len == 0) return Value.zero;
+            .Int, .Enum => {
                 const int_info = ty.intInfo(target);
-                const endian = target.cpu.arch.endian();
-                const Limb = std.math.big.Limb;
-                const limb_count = (buffer.len + @sizeOf(Limb) - 1) / @sizeOf(Limb);
-                const limbs_buffer = try arena.alloc(Limb, limb_count);
-                const abi_size = @intCast(usize, ty.abiSize(target));
-                var bigint = BigIntMutable.init(limbs_buffer, 0);
-                bigint.readTwosComplement(buffer, int_info.bits, abi_size, endian, int_info.signedness);
-                return fromBigInt(arena, bigint.toConst());
+                const bits = int_info.bits;
+                const byte_count = (bits + 7) / 8;
+                if (bits == 0 or buffer.len == 0) return Value.zero;
+
+                if (bits <= 64) switch (int_info.signedness) { // Fast path for integers <= u64
+                    .signed => {
+                        const val = std.mem.readVarInt(i64, buffer[0..byte_count], endian);
+                        return Value.Tag.int_i64.create(arena, (val << @intCast(u6, 64 - bits)) >> @intCast(u6, 64 - bits));
+                    },
+                    .unsigned => {
+                        const val = std.mem.readVarInt(u64, buffer[0..byte_count], endian);
+                        return Value.Tag.int_u64.create(arena, (val << @intCast(u6, 64 - bits)) >> @intCast(u6, 64 - bits));
+                    },
+                } else { // Slow path, we have to construct a big-int
+                    const Limb = std.math.big.Limb;
+                    const limb_count = (byte_count + @sizeOf(Limb) - 1) / @sizeOf(Limb);
+                    const limbs_buffer = try arena.alloc(Limb, limb_count);
+
+                    var bigint = BigIntMutable.init(limbs_buffer, 0);
+                    bigint.readTwosComplement(buffer[0..byte_count], bits, endian, int_info.signedness);
+                    return fromBigInt(arena, bigint.toConst());
+                }
             },
             .Float => switch (ty.floatBits(target)) {
-                16 => return Value.Tag.float_16.create(arena, floatReadFromMemory(f16, target, buffer)),
-                32 => return Value.Tag.float_32.create(arena, floatReadFromMemory(f32, target, buffer)),
-                64 => return Value.Tag.float_64.create(arena, floatReadFromMemory(f64, target, buffer)),
-                80 => return Value.Tag.float_80.create(arena, floatReadFromMemory(f80, target, buffer)),
-                128 => return Value.Tag.float_128.create(arena, floatReadFromMemory(f128, target, buffer)),
+                16 => return Value.Tag.float_16.create(arena, @bitCast(f16, std.mem.readInt(u16, buffer[0..2], endian))),
+                32 => return Value.Tag.float_32.create(arena, @bitCast(f32, std.mem.readInt(u32, buffer[0..4], endian))),
+                64 => return Value.Tag.float_64.create(arena, @bitCast(f64, std.mem.readInt(u64, buffer[0..8], endian))),
+                80 => return Value.Tag.float_80.create(arena, @bitCast(f80, std.mem.readInt(u80, buffer[0..10], endian))),
+                128 => return Value.Tag.float_128.create(arena, @bitCast(f128, std.mem.readInt(u128, buffer[0..16], endian))),
                 else => unreachable,
             },
-            .Array, .Vector => {
+            .Array => {
                 const elem_ty = ty.childType();
                 const elem_size = elem_ty.abiSize(target);
                 const elems = try arena.alloc(Value, @intCast(usize, ty.arrayLen()));
@@ -1429,6 +1455,12 @@ pub const Value = extern union {
                 }
                 return Tag.aggregate.create(arena, elems);
             },
+            .Vector => {
+                // We use byte_count instead of abi_size here, so that any padding bytes
+                // follow the data bytes, on both big- and little-endian systems.
+                const byte_count = (@intCast(usize, ty.bitSize(target)) + 7) / 8;
+                return readFromPackedMemory(ty, mod, buffer[0..byte_count], 0, arena);
+            },
             .Struct => switch (ty.containerLayout()) {
                 .Auto => unreachable, // Sema is supposed to have emitted a compile error already
                 .Extern => {
@@ -1436,26 +1468,20 @@ pub const Value = extern union {
                     const field_vals = try arena.alloc(Value, fields.len);
                     for (fields) |field, i| {
                         const off = @intCast(usize, ty.structFieldOffset(i, target));
-                        field_vals[i] = try readFromMemory(field.ty, mod, buffer[off..], arena);
+                        const sz = @intCast(usize, ty.structFieldType(i).abiSize(target));
+                        field_vals[i] = try readFromMemory(field.ty, mod, buffer[off..(off + sz)], arena);
                     }
                     return Tag.aggregate.create(arena, field_vals);
                 },
                 .Packed => {
-                    const endian = target.cpu.arch.endian();
-                    const Limb = std.math.big.Limb;
-                    const abi_size = @intCast(usize, ty.abiSize(target));
-                    const bit_size = @intCast(usize, ty.bitSize(target));
-                    const limb_count = (buffer.len + @sizeOf(Limb) - 1) / @sizeOf(Limb);
-                    const limbs_buffer = try arena.alloc(Limb, limb_count);
-                    var bigint = BigIntMutable.init(limbs_buffer, 0);
-                    bigint.readTwosComplement(buffer, bit_size, abi_size, endian, .unsigned);
-                    return intToPackedStruct(ty, target, bigint.toConst(), arena);
+                    const byte_count = (@intCast(usize, ty.bitSize(target)) + 7) / 8;
+                    return readFromPackedMemory(ty, mod, buffer[0..byte_count], 0, arena);
                 },
             },
             .ErrorSet => {
                 // TODO revisit this when we have the concept of the error tag type
                 const Int = u16;
-                const int = std.mem.readInt(Int, buffer[0..@sizeOf(Int)], target.cpu.arch.endian());
+                const int = std.mem.readInt(Int, buffer[0..@sizeOf(Int)], endian);
 
                 const payload = try arena.create(Value.Payload.Error);
                 payload.* = .{
@@ -1468,115 +1494,90 @@ pub const Value = extern union {
         }
     }
 
-    fn intToPackedStruct(
+    /// Load a Value from the contents of `buffer`.
+    ///
+    /// Both the start and the end of the provided buffer must be tight, since
+    /// big-endian packed memory layouts start at the end of the buffer.
+    pub fn readFromPackedMemory(
         ty: Type,
-        target: Target,
-        bigint: BigIntConst,
+        mod: *Module,
+        buffer: []const u8,
+        bit_offset: usize,
         arena: Allocator,
     ) Allocator.Error!Value {
-        const limbs_buffer = try arena.alloc(std.math.big.Limb, bigint.limbs.len);
-        var bigint_mut = bigint.toMutable(limbs_buffer);
-        const fields = ty.structFields().values();
-        const field_vals = try arena.alloc(Value, fields.len);
-        var bits: u16 = 0;
-        for (fields) |field, i| {
-            const field_bits = @intCast(u16, field.ty.bitSize(target));
-            bigint_mut.shiftRight(bigint, bits);
-            bigint_mut.truncate(bigint_mut.toConst(), .unsigned, field_bits);
-            bits += field_bits;
-            const field_bigint = bigint_mut.toConst();
+        const target = mod.getTarget();
+        const endian = target.cpu.arch.endian();
+        switch (ty.zigTypeTag()) {
+            .Void => return Value.@"void",
+            .Bool => {
+                const byte = switch (endian) {
+                    .Big => buffer[buffer.len - bit_offset / 8 - 1],
+                    .Little => buffer[bit_offset / 8],
+                };
+                if (((byte >> @intCast(u3, bit_offset % 8)) & 1) == 0) {
+                    return Value.@"false";
+                } else {
+                    return Value.@"true";
+                }
+            },
+            .Int, .Enum => {
+                if (buffer.len == 0) return Value.zero;
+                const int_info = ty.intInfo(target);
+                const abi_size = @intCast(usize, ty.abiSize(target));
 
-            field_vals[i] = switch (field.ty.zigTypeTag()) {
-                .Float => switch (field.ty.floatBits(target)) {
-                    16 => try bitCastBigIntToFloat(f16, .float_16, field_bigint, arena),
-                    32 => try bitCastBigIntToFloat(f32, .float_32, field_bigint, arena),
-                    64 => try bitCastBigIntToFloat(f64, .float_64, field_bigint, arena),
-                    80 => try bitCastBigIntToFloat(f80, .float_80, field_bigint, arena),
-                    128 => try bitCastBigIntToFloat(f128, .float_128, field_bigint, arena),
-                    else => unreachable,
-                },
-                .Bool => makeBool(!field_bigint.eqZero()),
-                .Int => try Tag.int_big_positive.create(
-                    arena,
-                    try arena.dupe(std.math.big.Limb, field_bigint.limbs),
-                ),
-                .Struct => try intToPackedStruct(field.ty, target, field_bigint, arena),
+                const bits = int_info.bits;
+                if (bits <= 64) switch (int_info.signedness) { // Fast path for integers <= u64
+                    .signed => return Value.Tag.int_i64.create(arena, std.mem.readVarPackedInt(i64, buffer, bit_offset, bits, endian, .signed)),
+                    .unsigned => return Value.Tag.int_u64.create(arena, std.mem.readVarPackedInt(u64, buffer, bit_offset, bits, endian, .unsigned)),
+                } else { // Slow path, we have to construct a big-int
+                    const Limb = std.math.big.Limb;
+                    const limb_count = (abi_size + @sizeOf(Limb) - 1) / @sizeOf(Limb);
+                    const limbs_buffer = try arena.alloc(Limb, limb_count);
+
+                    var bigint = BigIntMutable.init(limbs_buffer, 0);
+                    bigint.readPackedTwosComplement(buffer, bit_offset, bits, endian, int_info.signedness);
+                    return fromBigInt(arena, bigint.toConst());
+                }
+            },
+            .Float => switch (ty.floatBits(target)) {
+                16 => return Value.Tag.float_16.create(arena, @bitCast(f16, std.mem.readPackedInt(u16, buffer, bit_offset, endian))),
+                32 => return Value.Tag.float_32.create(arena, @bitCast(f32, std.mem.readPackedInt(u32, buffer, bit_offset, endian))),
+                64 => return Value.Tag.float_64.create(arena, @bitCast(f64, std.mem.readPackedInt(u64, buffer, bit_offset, endian))),
+                80 => return Value.Tag.float_80.create(arena, @bitCast(f80, std.mem.readPackedInt(u80, buffer, bit_offset, endian))),
+                128 => return Value.Tag.float_128.create(arena, @bitCast(f128, std.mem.readPackedInt(u128, buffer, bit_offset, endian))),
                 else => unreachable,
-            };
-        }
-        return Tag.aggregate.create(arena, field_vals);
-    }
-
-    fn bitCastBigIntToFloat(
-        comptime F: type,
-        comptime float_tag: Tag,
-        bigint: BigIntConst,
-        arena: Allocator,
-    ) !Value {
-        const Int = @Type(.{ .Int = .{
-            .signedness = .unsigned,
-            .bits = @typeInfo(F).Float.bits,
-        } });
-        const int = bigint.to(Int) catch |err| switch (err) {
-            error.NegativeIntoUnsigned => unreachable,
-            error.TargetTooSmall => unreachable,
-        };
-        const f = @bitCast(F, int);
-        return float_tag.create(arena, f);
-    }
-
-    fn floatWriteToMemory(comptime F: type, f: F, target: Target, buffer: []u8) void {
-        const endian = target.cpu.arch.endian();
-        if (F == f80) {
-            const repr = std.math.break_f80(f);
-            std.mem.writeInt(u64, buffer[0..8], repr.fraction, endian);
-            std.mem.writeInt(u16, buffer[8..10], repr.exp, endian);
-            std.mem.set(u8, buffer[10..], 0);
-            return;
-        }
-        const Int = @Type(.{ .Int = .{
-            .signedness = .unsigned,
-            .bits = @typeInfo(F).Float.bits,
-        } });
-        const int = @bitCast(Int, f);
-        std.mem.writeInt(Int, buffer[0..@sizeOf(Int)], int, endian);
-    }
-
-    fn floatReadFromMemory(comptime F: type, target: Target, buffer: []const u8) F {
-        const endian = target.cpu.arch.endian();
-        if (F == f80) {
-            return std.math.make_f80(.{
-                .fraction = readInt(u64, buffer[0..8], endian),
-                .exp = readInt(u16, buffer[8..10], endian),
-            });
-        }
-        const Int = @Type(.{ .Int = .{
-            .signedness = .unsigned,
-            .bits = @typeInfo(F).Float.bits,
-        } });
-        const int = readInt(Int, buffer[0..@sizeOf(Int)], endian);
-        return @bitCast(F, int);
-    }
-
-    fn readInt(comptime Int: type, buffer: *const [@sizeOf(Int)]u8, endian: std.builtin.Endian) Int {
-        var result: Int = 0;
-        switch (endian) {
-            .Big => {
-                for (buffer) |byte| {
-                    result <<= 8;
-                    result |= byte;
-                }
             },
-            .Little => {
-                var i: usize = buffer.len;
-                while (i != 0) {
-                    i -= 1;
-                    result <<= 8;
-                    result |= buffer[i];
+            .Vector => {
+                const elem_ty = ty.childType();
+                const elems = try arena.alloc(Value, @intCast(usize, ty.arrayLen()));
+
+                var bits: u16 = 0;
+                const elem_bit_size = @intCast(u16, elem_ty.bitSize(target));
+                for (elems) |_, i| {
+                    // On big-endian systems, LLVM reverses the element order of vectors by default
+                    const tgt_elem_i = if (endian == .Big) elems.len - i - 1 else i;
+                    elems[tgt_elem_i] = try readFromPackedMemory(elem_ty, mod, buffer, bit_offset + bits, arena);
+                    bits += elem_bit_size;
                 }
+                return Tag.aggregate.create(arena, elems);
             },
+            .Struct => switch (ty.containerLayout()) {
+                .Auto => unreachable, // Sema is supposed to have emitted a compile error already
+                .Extern => unreachable, // Handled by non-packed readFromMemory
+                .Packed => {
+                    var bits: u16 = 0;
+                    const fields = ty.structFields().values();
+                    const field_vals = try arena.alloc(Value, fields.len);
+                    for (fields) |field, i| {
+                        const field_bits = @intCast(u16, field.ty.bitSize(target));
+                        field_vals[i] = try readFromPackedMemory(field.ty, mod, buffer, bit_offset + bits, arena);
+                        bits += field_bits;
+                    }
+                    return Tag.aggregate.create(arena, field_vals);
+                },
+            },
+            else => @panic("TODO implement readFromPackedMemory for more types"),
         }
-        return result;
     }
 
     /// Asserts that the value is a float or an integer.
diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig
index c629a1a34b..b225c31858 100644
--- a/test/behavior/bitcast.zig
+++ b/test/behavior/bitcast.zig
@@ -63,6 +63,10 @@ fn testBitCast(comptime N: usize) !void {
     try expect(conv_iN(N, 0) == 0);
 
     try expect(conv_iN(N, -0) == 0);
+
+    if (N > 24) {
+        try expect(conv_uN(N, 0xf23456) == 0xf23456);
+    }
 }
 
 fn conv_iN(comptime N: usize, x: std.meta.Int(.signed, N)) std.meta.Int(.unsigned, N) {
@@ -73,6 +77,55 @@ fn conv_uN(comptime N: usize, x: std.meta.Int(.unsigned, N)) std.meta.Int(.signe
     return @bitCast(std.meta.Int(.signed, N), x);
 }
 
+test "bitcast uX to bytes" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
+
+    const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 };
+    inline for (bit_values) |bits| {
+        try testBitCast(bits);
+        comptime try testBitCast(bits);
+    }
+}
+
+fn testBitCastuXToBytes(comptime N: usize) !void {
+
+    // The location of padding bits in these layouts are technically not defined
+    // by LLVM, but we currently allow exotic integers to be cast (at comptime)
+    // to types that expose their padding bits anyway.
+    //
+    // This test at least makes sure those bits are matched by the runtime behavior
+    // on the platforms we target. If the above behavior is restricted after all,
+    // this test should be deleted.
+
+    const T = std.meta.Int(.unsigned, N);
+    for ([_]T{ 0, ~@as(T, 0) }) |init_value| {
+        var x: T = init_value;
+        const bytes = std.mem.asBytes(&x);
+
+        const byte_count = (N + 7) / 8;
+        switch (builtin.cpu.arch.endian()) {
+            .Little => {
+                var byte_i = 0;
+                while (byte_i < (byte_count - 1)) : (byte_i += 1) {
+                    try expect(bytes[byte_i] == 0xff);
+                }
+                try expect(((bytes[byte_i] ^ 0xff) << -%@truncate(u3, N)) == 0);
+            },
+            .Big => {
+                var byte_i = byte_count - 1;
+                while (byte_i > 0) : (byte_i -= 1) {
+                    try expect(bytes[byte_i] == 0xff);
+                }
+                try expect(((bytes[byte_i] ^ 0xff) << -%@truncate(u3, N)) == 0);
+            },
+        }
+    }
+}
+
 test "nested bitcast" {
     const S = struct {
         fn moo(x: isize) !void {
@@ -283,7 +336,8 @@ test "@bitCast packed struct of floats" {
     comptime try S.doTheTest();
 }
 
-test "comptime @bitCast packed struct to int" {
+test "comptime @bitCast packed struct to int and back" {
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
@@ -304,6 +358,37 @@ test "comptime @bitCast packed struct to int" {
         vectorf: @Vector(2, f16) = .{ 3.14, 2.71 },
     };
     const Int = @typeInfo(S).Struct.backing_integer.?;
+
+    // S -> Int
     var s: S = .{};
     try expectEqual(@bitCast(Int, s), comptime @bitCast(Int, S{}));
+
+    // Int -> S
+    var i: Int = 0;
+    const rt_cast = @bitCast(S, i);
+    const ct_cast = comptime @bitCast(S, @as(Int, 0));
+    inline for (@typeInfo(S).Struct.fields) |field| {
+        if (@typeInfo(field.field_type) == .Vector)
+            continue; //TODO: https://github.com/ziglang/zig/issues/13201
+
+        try expectEqual(@field(rt_cast, field.name), @field(ct_cast, field.name));
+    }
+}
+
+test "comptime bitcast with fields following a float" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO: https://github.com/ziglang/zig/issues/13214
+
+    const FloatT = extern struct { f: f80, x: u128 };
+    var x: FloatT = .{ .f = 0.5, .x = 123 };
+    try expect(@bitCast(u256, x) == comptime @bitCast(u256, @as(FloatT, .{ .f = 0.5, .x = 123 })));
+}
+
+test "bitcast vector to integer and back" {
+    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO: https://github.com/ziglang/zig/issues/13220
+    if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 gets the comptime cast wrong
+
+    const arr: [16]bool = [_]bool{ true, false } ++ [_]bool{true} ** 14;
+    var x = @splat(16, true);
+    x[1] = false;
+    try expect(@bitCast(u16, x) == comptime @bitCast(u16, @as(@Vector(16, bool), arr)));
 }

From 9d0a4b60e1c715238f96a64c45619a680f94c300 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Wed, 19 Oct 2022 12:02:21 -0700
Subject: [PATCH 60/70] Value: Add `@intCast` in `writeToPackedMemory` for
 32-bit targets

---
 src/value.zig | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/value.zig b/src/value.zig
index 7468a69fda..2ecfaefa56 100644
--- a/src/value.zig
+++ b/src/value.zig
@@ -1357,9 +1357,9 @@ pub const Value = extern union {
                 else => unreachable,
             },
             .Vector => {
-                const len = ty.arrayLen();
                 const elem_ty = ty.childType();
                 const elem_bit_size = @intCast(u16, elem_ty.bitSize(target));
+                const len = @intCast(usize, ty.arrayLen());
 
                 var bits: u16 = 0;
                 var elem_i: usize = 0;

From 03ed0a59e337d89c9650cc8a70ff431b66ee8671 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Wed, 19 Oct 2022 12:14:18 -0700
Subject: [PATCH 61/70] std.mem: Skip `read/writePackedInt` test on WASM32/64

---
 lib/std/mem.zig | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index f0403942f1..29bbf05f77 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -3700,6 +3700,13 @@ pub fn alignInSlice(slice: anytype, comptime new_alignment: usize) ?AlignedSlice
 }
 
 test "read/write(Var)PackedInt" {
+    switch (builtin.cpu.arch) {
+        // This test generates too much code to execute on WASI.
+        // LLVM backend fails with "too many locals: locals exceed maximum"
+        .wasm32, .wasm64 => return error.SkipZigTest,
+        else => {},
+    }
+
     const foreign_endian: Endian = if (native_endian == .Big) .Little else .Big;
     const expect = std.testing.expect;
     var prng = std.rand.DefaultPrng.init(1234);

From 40b7792a4c815868bafe882cc77d89a67c08571b Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Fri, 28 Oct 2022 08:51:15 -0700
Subject: [PATCH 62/70] Enable bitcast test now that #13214 is resolved.

---
 test/behavior/bitcast.zig | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/test/behavior/bitcast.zig b/test/behavior/bitcast.zig
index b225c31858..728e8fe62a 100644
--- a/test/behavior/bitcast.zig
+++ b/test/behavior/bitcast.zig
@@ -375,12 +375,19 @@ test "comptime @bitCast packed struct to int and back" {
     }
 }
 
-test "comptime bitcast with fields following a float" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO: https://github.com/ziglang/zig/issues/13214
+test "comptime bitcast with fields following f80" {
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
-    const FloatT = extern struct { f: f80, x: u128 };
-    var x: FloatT = .{ .f = 0.5, .x = 123 };
-    try expect(@bitCast(u256, x) == comptime @bitCast(u256, @as(FloatT, .{ .f = 0.5, .x = 123 })));
+    const FloatT = extern struct { f: f80, x: u128 align(16) };
+    const x: FloatT = .{ .f = 0.5, .x = 123 };
+    var x_as_uint: u256 = comptime @bitCast(u256, x);
+
+    try expect(x.f == @bitCast(FloatT, x_as_uint).f);
+    try expect(x.x == @bitCast(FloatT, x_as_uint).x);
 }
 
 test "bitcast vector to integer and back" {

From c616141241047d6d6c811d43f644eb1b7d2b26ce Mon Sep 17 00:00:00 2001
From: Evan Haas <evan@lagerdata.com>
Date: Thu, 27 Oct 2022 23:53:08 -0700
Subject: [PATCH 63/70] translate-c: Better support for division in macros

Perform C-style arithmetic conversions on operands to division operator
in macros

Closes #13162
---
 lib/std/zig/c_translation.zig        | 126 +++++++++++++++++++++++++++
 src/translate_c.zig                  |   2 +-
 src/translate_c/ast.zig              |  24 +++++
 test/behavior/translate_c_macros.h   |   3 +
 test/behavior/translate_c_macros.zig |  34 ++++++++
 5 files changed, 188 insertions(+), 1 deletion(-)

diff --git a/lib/std/zig/c_translation.zig b/lib/std/zig/c_translation.zig
index 6bc664f04c..664cb09ae4 100644
--- a/lib/std/zig/c_translation.zig
+++ b/lib/std/zig/c_translation.zig
@@ -40,6 +40,17 @@ pub fn cast(comptime DestType: type, target: anytype) DestType {
                 .Fn => {
                     return castInt(DestType, @ptrToInt(&target));
                 },
+                .Bool => {
+                    return @boolToInt(target);
+                },
+                else => {},
+            }
+        },
+        .Float => {
+            switch (@typeInfo(SourceType)) {
+                .Int => return @intToFloat(DestType, target),
+                .Float => return @floatCast(DestType, target),
+                .Bool => return @intToFloat(DestType, @boolToInt(target)),
                 else => {},
             }
         },
@@ -446,6 +457,121 @@ pub const Macros = struct {
     }
 };
 
+/// Integer promotion described in C11 6.3.1.1.2
+fn PromotedIntType(comptime T: type) type {
+    return switch (T) {
+        bool, u8, i8, c_short => c_int,
+        c_ushort => if (@sizeOf(c_ushort) == @sizeOf(c_int)) c_uint else c_int,
+        c_int, c_uint, c_long, c_ulong, c_longlong, c_ulonglong => T,
+        else => if (T == comptime_int) {
+            @compileError("Cannot promote `" ++ @typeName(T) ++ "`; a fixed-size number type is required");
+        } else if (@typeInfo(T) == .Int) {
+            @compileError("Cannot promote `" ++ @typeName(T) ++ "`; a C ABI type is required");
+        } else {
+            @compileError("Attempted to promote invalid type `" ++ @typeName(T) ++ "`");
+        },
+    };
+}
+
+/// C11 6.3.1.1.1
+fn integerRank(comptime T: type) u8 {
+    return switch (T) {
+        bool => 0,
+        u8, i8 => 1,
+        c_short, c_ushort => 2,
+        c_int, c_uint => 3,
+        c_long, c_ulong => 4,
+        c_longlong, c_ulonglong => 5,
+        else => @compileError("integer rank not supported for `" ++ @typeName(T) ++ "`"),
+    };
+}
+
+fn ToUnsigned(comptime T: type) type {
+    return switch (T) {
+        c_int => c_uint,
+        c_long => c_ulong,
+        c_longlong => c_ulonglong,
+        else => @compileError("Cannot convert `" ++ @typeName(T) ++ "` to unsigned"),
+    };
+}
+
+/// "Usual arithmetic conversions" from C11 standard 6.3.1.8
+fn ArithmeticConversion(comptime A: type, comptime B: type) type {
+    if (A == c_longdouble or B == c_longdouble) return c_longdouble;
+    if (A == f80 or B == f80) return f80;
+    if (A == f64 or B == f64) return f64;
+    if (A == f32 or B == f32) return f32;
+
+    const A_Promoted = PromotedIntType(A);
+    const B_Promoted = PromotedIntType(B);
+    comptime {
+        std.debug.assert(integerRank(A_Promoted) >= integerRank(c_int));
+        std.debug.assert(integerRank(B_Promoted) >= integerRank(c_int));
+    }
+
+    if (A_Promoted == B_Promoted) return A_Promoted;
+
+    const a_signed = @typeInfo(A_Promoted).Int.signedness == .signed;
+    const b_signed = @typeInfo(B_Promoted).Int.signedness == .signed;
+
+    if (a_signed == b_signed) {
+        return if (integerRank(A_Promoted) > integerRank(B_Promoted)) A_Promoted else B_Promoted;
+    }
+
+    const SignedType = if (a_signed) A_Promoted else B_Promoted;
+    const UnsignedType = if (!a_signed) A_Promoted else B_Promoted;
+
+    if (integerRank(UnsignedType) >= integerRank(SignedType)) return UnsignedType;
+
+    if (std.math.maxInt(SignedType) >= std.math.maxInt(UnsignedType)) return SignedType;
+
+    return ToUnsigned(SignedType);
+}
+
+test "ArithmeticConversion" {
+    // Promotions not necessarily the same for other platforms
+    if (builtin.target.cpu.arch != .x86_64 or builtin.target.os.tag != .linux) return error.SkipZigTest;
+
+    const Test = struct {
+        /// Order of operands should not matter for arithmetic conversions
+        fn checkPromotion(comptime A: type, comptime B: type, comptime Expected: type) !void {
+            try std.testing.expect(ArithmeticConversion(A, B) == Expected);
+            try std.testing.expect(ArithmeticConversion(B, A) == Expected);
+        }
+    };
+
+    try Test.checkPromotion(c_longdouble, c_int, c_longdouble);
+    try Test.checkPromotion(c_int, f64, f64);
+    try Test.checkPromotion(f32, bool, f32);
+
+    try Test.checkPromotion(bool, c_short, c_int);
+    try Test.checkPromotion(c_int, c_int, c_int);
+    try Test.checkPromotion(c_short, c_int, c_int);
+
+    try Test.checkPromotion(c_int, c_long, c_long);
+
+    try Test.checkPromotion(c_ulonglong, c_uint, c_ulonglong);
+
+    try Test.checkPromotion(c_uint, c_int, c_uint);
+
+    try Test.checkPromotion(c_uint, c_long, c_long);
+
+    try Test.checkPromotion(c_ulong, c_longlong, c_ulonglong);
+}
+
+pub const MacroArithmetic = struct {
+    pub fn div(a: anytype, b: anytype) ArithmeticConversion(@TypeOf(a), @TypeOf(b)) {
+        const ResType = ArithmeticConversion(@TypeOf(a), @TypeOf(b));
+        const a_casted = cast(ResType, a);
+        const b_casted = cast(ResType, b);
+        switch (@typeInfo(ResType)) {
+            .Float => return a_casted / b_casted,
+            .Int => return @divTrunc(a_casted, b_casted),
+            else => unreachable,
+        }
+    }
+};
+
 test "Macro suffix functions" {
     try testing.expect(@TypeOf(Macros.F_SUFFIX(1)) == f32);
 
diff --git a/src/translate_c.zig b/src/translate_c.zig
index 7cc843e17c..693f274e8e 100644
--- a/src/translate_c.zig
+++ b/src/translate_c.zig
@@ -6232,7 +6232,7 @@ fn parseCMulExpr(c: *Context, m: *MacroCtx, scope: *Scope) ParseError!Node {
             .Slash => {
                 const lhs = try macroBoolToInt(c, node);
                 const rhs = try macroBoolToInt(c, try parseCCastExpr(c, m, scope));
-                node = try Tag.div.create(c.arena, .{ .lhs = lhs, .rhs = rhs });
+                node = try Tag.macro_arithmetic.create(c.arena, .{ .op = .div, .lhs = lhs, .rhs = rhs });
             },
             .Percent => {
                 const lhs = try macroBoolToInt(c, node);
diff --git a/src/translate_c/ast.zig b/src/translate_c/ast.zig
index 4dcdbc4250..4a64c13ce7 100644
--- a/src/translate_c/ast.zig
+++ b/src/translate_c/ast.zig
@@ -159,6 +159,9 @@ pub const Node = extern union {
         /// @shuffle(type, a, b, mask)
         shuffle,
 
+        /// @import("std").zig.c_translation.MacroArithmetic.<op>(lhs, rhs)
+        macro_arithmetic,
+
         asm_simple,
 
         negate,
@@ -370,6 +373,7 @@ pub const Node = extern union {
                 .field_access => Payload.FieldAccess,
                 .string_slice => Payload.StringSlice,
                 .shuffle => Payload.Shuffle,
+                .macro_arithmetic => Payload.MacroArithmetic,
             };
         }
 
@@ -713,6 +717,19 @@ pub const Payload = struct {
             mask_vector: Node,
         },
     };
+
+    pub const MacroArithmetic = struct {
+        base: Payload,
+        data: struct {
+            op: Operator,
+            lhs: Node,
+            rhs: Node,
+        },
+
+        pub const Operator = enum {
+            div,
+        };
+    };
 };
 
 /// Converts the nodes into a Zig Ast.
@@ -1408,6 +1425,12 @@ fn renderNode(c: *Context, node: Node) Allocator.Error!NodeIndex {
                 payload.mask_vector,
             });
         },
+        .macro_arithmetic => {
+            const payload = node.castTag(.macro_arithmetic).?.data;
+            const op = @tagName(payload.op);
+            const import_node = try renderStdImport(c, &.{ "zig", "c_translation", "MacroArithmetic", op });
+            return renderCall(c, import_node, &.{ payload.lhs, payload.rhs });
+        },
         .alignof => {
             const payload = node.castTag(.alignof).?.data;
             return renderBuiltinCall(c, "@alignOf", &.{payload});
@@ -2349,6 +2372,7 @@ fn renderNodeGrouped(c: *Context, node: Node) !NodeIndex {
         .shuffle,
         .static_local_var,
         .mut_str,
+        .macro_arithmetic,
         => {
             // no grouping needed
             return renderNode(c, node);
diff --git a/test/behavior/translate_c_macros.h b/test/behavior/translate_c_macros.h
index 5d4cf3473d..fc9aaaaf52 100644
--- a/test/behavior/translate_c_macros.h
+++ b/test/behavior/translate_c_macros.h
@@ -53,3 +53,6 @@ typedef _Bool uintptr_t;
 #define LARGE_INT 18446744073709550592
 
 #define EMBEDDED_TAB "hello	"
+
+#define DIVIDE_CONSTANT(version) (version / 1000)
+#define DIVIDE_ARGS(A, B) (A / B)
diff --git a/test/behavior/translate_c_macros.zig b/test/behavior/translate_c_macros.zig
index deda45df91..29cd949508 100644
--- a/test/behavior/translate_c_macros.zig
+++ b/test/behavior/translate_c_macros.zig
@@ -147,3 +147,37 @@ test "string and char literals that are not UTF-8 encoded. Issue #12784" {
     try expectEqual(@as(u8, '\xA9'), latin1.UNPRINTABLE_CHAR);
     try expectEqualStrings("\xA9\xA9\xA9", latin1.UNPRINTABLE_STRING);
 }
+
+test "Macro that uses division operator. Issue #13162" {
+    if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+
+    try expectEqual(@as(c_int, 42), h.DIVIDE_CONSTANT(@as(c_int, 42_000)));
+    try expectEqual(@as(c_uint, 42), h.DIVIDE_CONSTANT(@as(c_uint, 42_000)));
+
+    try expectEqual(
+        @as(f64, 42.0),
+        h.DIVIDE_ARGS(
+            @as(f64, 42.0),
+            true,
+        ),
+    );
+    try expectEqual(
+        @as(c_int, 21),
+        h.DIVIDE_ARGS(
+            @as(i8, 42),
+            @as(i8, 2),
+        ),
+    );
+
+    try expectEqual(
+        @as(c_int, 21),
+        h.DIVIDE_ARGS(
+            @as(c_ushort, 42),
+            @as(c_ushort, 2),
+        ),
+    );
+}

From 10edb6d352173dfbc9962ce3db064384319e77f8 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Sat, 22 Oct 2022 23:50:38 -0700
Subject: [PATCH 64/70] crypto.sha2: Use intrinsics for SHA-256 on x86-64 and
 AArch64

There's probably plenty of room to optimize these further in the
future, but for the moment this gives ~3x improvement on Intel
x86-64 processors, ~5x on AMD, and ~10x on M1 Macs.

These extensions are very new - Most processors prior to 2020 do
not support them.

AVX-512 is a slightly older alternative that we could use on Intel
for a much bigger performance bump, but it's been fused off on
Intel's latest hybrid architectures and it relies on computing
independent SHA hashes in parallel. In contrast, these SHA intrinsics
provide the usual single-threaded, single-stream interface, and should
continue working on new processors.

AArch64 also has SHA-512 intrinsics that we could take advantage
of in the future
---
 lib/std/crypto/sha2.zig | 234 ++++++++++++++++++++++++++++------------
 1 file changed, 164 insertions(+), 70 deletions(-)

diff --git a/lib/std/crypto/sha2.zig b/lib/std/crypto/sha2.zig
index b7a78c4b44..d51c2e8cc7 100644
--- a/lib/std/crypto/sha2.zig
+++ b/lib/std/crypto/sha2.zig
@@ -1,4 +1,5 @@
 const std = @import("../std.zig");
+const builtin = @import("builtin");
 const mem = std.mem;
 const math = std.math;
 const htest = @import("test.zig");
@@ -16,10 +17,9 @@ const RoundParam256 = struct {
     g: usize,
     h: usize,
     i: usize,
-    k: u32,
 };
 
-fn roundParam256(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g: usize, h: usize, i: usize, k: u32) RoundParam256 {
+fn roundParam256(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g: usize, h: usize, i: usize) RoundParam256 {
     return RoundParam256{
         .a = a,
         .b = b,
@@ -30,7 +30,6 @@ fn roundParam256(a: usize, b: usize, c: usize, d: usize, e: usize, f: usize, g:
         .g = g,
         .h = h,
         .i = i,
-        .k = k,
     };
 }
 
@@ -70,6 +69,8 @@ const Sha256Params = Sha2Params32{
     .digest_bits = 256,
 };
 
+const v4u32 = @Vector(4, u32);
+
 /// SHA-224
 pub const Sha224 = Sha2x32(Sha224Params);
 
@@ -83,7 +84,7 @@ fn Sha2x32(comptime params: Sha2Params32) type {
         pub const digest_length = params.digest_bits / 8;
         pub const Options = struct {};
 
-        s: [8]u32,
+        s: [8]u32 align(16),
         // Streaming Cache
         buf: [64]u8 = undefined,
         buf_len: u8 = 0,
@@ -168,8 +169,19 @@ fn Sha2x32(comptime params: Sha2Params32) type {
             }
         }
 
+        const W = [64]u32{
+            0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
+            0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
+            0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
+            0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
+            0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
+            0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
+            0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
+            0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2,
+        };
+
         fn round(d: *Self, b: *const [64]u8) void {
-            var s: [64]u32 = undefined;
+            var s: [64]u32 align(16) = undefined;
 
             var i: usize = 0;
             while (i < 16) : (i += 1) {
@@ -179,6 +191,88 @@ fn Sha2x32(comptime params: Sha2Params32) type {
                 s[i] |= @as(u32, b[i * 4 + 2]) << 8;
                 s[i] |= @as(u32, b[i * 4 + 3]) << 0;
             }
+
+            if (builtin.cpu.arch == .aarch64 and builtin.cpu.features.isEnabled(@enumToInt(std.Target.aarch64.Feature.sha2))) {
+                var x: v4u32 = d.s[0..4].*;
+                var y: v4u32 = d.s[4..8].*;
+                const s_v = @ptrCast(*[16]v4u32, &s);
+
+                comptime var k: u8 = 0;
+                inline while (k < 16) : (k += 1) {
+                    if (k > 3) {
+                        s_v[k] = asm (
+                            \\sha256su0.4s %[w0_3], %[w4_7]
+                            \\sha256su1.4s %[w0_3], %[w8_11], %[w12_15]
+                            : [w0_3] "=w" (-> v4u32),
+                            : [_] "0" (s_v[k - 4]),
+                              [w4_7] "w" (s_v[k - 3]),
+                              [w8_11] "w" (s_v[k - 2]),
+                              [w12_15] "w" (s_v[k - 1]),
+                        );
+                    }
+
+                    const w: v4u32 = s_v[k] +% @as(v4u32, W[4 * k ..][0..4].*);
+                    asm volatile (
+                        \\mov.4s v0, %[x]
+                        \\sha256h.4s %[x], %[y], %[w]
+                        \\sha256h2.4s %[y], v0, %[w]
+                        : [x] "=w" (x),
+                          [y] "=w" (y),
+                        : [_] "0" (x),
+                          [_] "1" (y),
+                          [w] "w" (w),
+                        : "v0"
+                    );
+                }
+
+                d.s[0..4].* = x +% @as(v4u32, d.s[0..4].*);
+                d.s[4..8].* = y +% @as(v4u32, d.s[4..8].*);
+                return;
+            } else if (builtin.cpu.arch == .x86_64 and builtin.cpu.features.isEnabled(@enumToInt(std.Target.x86.Feature.sha))) {
+                var x: v4u32 = [_]u32{ d.s[5], d.s[4], d.s[1], d.s[0] };
+                var y: v4u32 = [_]u32{ d.s[7], d.s[6], d.s[3], d.s[2] };
+                const s_v = @ptrCast(*[16]v4u32, &s);
+
+                comptime var k: u8 = 0;
+                inline while (k < 16) : (k += 1) {
+                    if (k < 12) {
+                        const r = asm ("sha256msg1 %[w4_7], %[w0_3]"
+                            : [w0_3] "=x" (-> v4u32),
+                            : [_] "0" (s_v[k]),
+                              [w4_7] "x" (s_v[k + 1]),
+                        );
+                        const t = @shuffle(u32, s_v[k + 2], s_v[k + 3], [_]i32{ 1, 2, 3, -1 });
+                        s_v[k + 4] = asm ("sha256msg2 %[w12_15], %[t]"
+                            : [t] "=x" (-> v4u32),
+                            : [_] "0" (r +% t),
+                              [w12_15] "x" (s_v[k + 3]),
+                        );
+                    }
+
+                    const w: v4u32 = s_v[k] +% @as(v4u32, W[4 * k ..][0..4].*);
+                    asm volatile (
+                        \\sha256rnds2 %[x], %[y]
+                        \\pshufd $0xe, %%xmm0, %%xmm0
+                        \\sha256rnds2 %[y], %[x]
+                        : [y] "=x" (y),
+                          [x] "=x" (x),
+                        : [_] "0" (y),
+                          [_] "1" (x),
+                          [_] "{xmm0}" (w),
+                    );
+                }
+
+                d.s[0] +%= x[3];
+                d.s[1] +%= x[2];
+                d.s[4] +%= x[1];
+                d.s[5] +%= x[0];
+                d.s[2] +%= y[3];
+                d.s[3] +%= y[2];
+                d.s[6] +%= y[1];
+                d.s[7] +%= y[0];
+                return;
+            }
+
             while (i < 64) : (i += 1) {
                 s[i] = s[i - 16] +% s[i - 7] +% (math.rotr(u32, s[i - 15], @as(u32, 7)) ^ math.rotr(u32, s[i - 15], @as(u32, 18)) ^ (s[i - 15] >> 3)) +% (math.rotr(u32, s[i - 2], @as(u32, 17)) ^ math.rotr(u32, s[i - 2], @as(u32, 19)) ^ (s[i - 2] >> 10));
             }
@@ -195,73 +289,73 @@ fn Sha2x32(comptime params: Sha2Params32) type {
             };
 
             const round0 = comptime [_]RoundParam256{
-                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 0, 0x428A2F98),
-                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 1, 0x71374491),
-                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 2, 0xB5C0FBCF),
-                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 3, 0xE9B5DBA5),
-                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 4, 0x3956C25B),
-                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 5, 0x59F111F1),
-                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 6, 0x923F82A4),
-                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 7, 0xAB1C5ED5),
-                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 8, 0xD807AA98),
-                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 9, 0x12835B01),
-                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 10, 0x243185BE),
-                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 11, 0x550C7DC3),
-                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 12, 0x72BE5D74),
-                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 13, 0x80DEB1FE),
-                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 14, 0x9BDC06A7),
-                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 15, 0xC19BF174),
-                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 16, 0xE49B69C1),
-                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 17, 0xEFBE4786),
-                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 18, 0x0FC19DC6),
-                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 19, 0x240CA1CC),
-                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 20, 0x2DE92C6F),
-                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 21, 0x4A7484AA),
-                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 22, 0x5CB0A9DC),
-                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 23, 0x76F988DA),
-                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 24, 0x983E5152),
-                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 25, 0xA831C66D),
-                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 26, 0xB00327C8),
-                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 27, 0xBF597FC7),
-                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 28, 0xC6E00BF3),
-                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 29, 0xD5A79147),
-                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 30, 0x06CA6351),
-                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 31, 0x14292967),
-                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 32, 0x27B70A85),
-                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 33, 0x2E1B2138),
-                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 34, 0x4D2C6DFC),
-                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 35, 0x53380D13),
-                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 36, 0x650A7354),
-                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 37, 0x766A0ABB),
-                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 38, 0x81C2C92E),
-                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 39, 0x92722C85),
-                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 40, 0xA2BFE8A1),
-                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 41, 0xA81A664B),
-                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 42, 0xC24B8B70),
-                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 43, 0xC76C51A3),
-                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 44, 0xD192E819),
-                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 45, 0xD6990624),
-                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 46, 0xF40E3585),
-                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 47, 0x106AA070),
-                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 48, 0x19A4C116),
-                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 49, 0x1E376C08),
-                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 50, 0x2748774C),
-                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 51, 0x34B0BCB5),
-                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 52, 0x391C0CB3),
-                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 53, 0x4ED8AA4A),
-                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 54, 0x5B9CCA4F),
-                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 55, 0x682E6FF3),
-                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 56, 0x748F82EE),
-                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 57, 0x78A5636F),
-                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 58, 0x84C87814),
-                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 59, 0x8CC70208),
-                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 60, 0x90BEFFFA),
-                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 61, 0xA4506CEB),
-                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 62, 0xBEF9A3F7),
-                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 63, 0xC67178F2),
+                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 0),
+                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 1),
+                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 2),
+                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 3),
+                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 4),
+                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 5),
+                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 6),
+                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 7),
+                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 8),
+                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 9),
+                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 10),
+                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 11),
+                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 12),
+                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 13),
+                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 14),
+                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 15),
+                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 16),
+                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 17),
+                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 18),
+                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 19),
+                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 20),
+                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 21),
+                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 22),
+                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 23),
+                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 24),
+                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 25),
+                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 26),
+                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 27),
+                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 28),
+                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 29),
+                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 30),
+                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 31),
+                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 32),
+                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 33),
+                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 34),
+                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 35),
+                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 36),
+                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 37),
+                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 38),
+                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 39),
+                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 40),
+                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 41),
+                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 42),
+                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 43),
+                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 44),
+                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 45),
+                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 46),
+                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 47),
+                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 48),
+                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 49),
+                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 50),
+                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 51),
+                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 52),
+                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 53),
+                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 54),
+                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 55),
+                roundParam256(0, 1, 2, 3, 4, 5, 6, 7, 56),
+                roundParam256(7, 0, 1, 2, 3, 4, 5, 6, 57),
+                roundParam256(6, 7, 0, 1, 2, 3, 4, 5, 58),
+                roundParam256(5, 6, 7, 0, 1, 2, 3, 4, 59),
+                roundParam256(4, 5, 6, 7, 0, 1, 2, 3, 60),
+                roundParam256(3, 4, 5, 6, 7, 0, 1, 2, 61),
+                roundParam256(2, 3, 4, 5, 6, 7, 0, 1, 62),
+                roundParam256(1, 2, 3, 4, 5, 6, 7, 0, 63),
             };
             inline for (round0) |r| {
-                v[r.h] = v[r.h] +% (math.rotr(u32, v[r.e], @as(u32, 6)) ^ math.rotr(u32, v[r.e], @as(u32, 11)) ^ math.rotr(u32, v[r.e], @as(u32, 25))) +% (v[r.g] ^ (v[r.e] & (v[r.f] ^ v[r.g]))) +% r.k +% s[r.i];
+                v[r.h] = v[r.h] +% (math.rotr(u32, v[r.e], @as(u32, 6)) ^ math.rotr(u32, v[r.e], @as(u32, 11)) ^ math.rotr(u32, v[r.e], @as(u32, 25))) +% (v[r.g] ^ (v[r.e] & (v[r.f] ^ v[r.g]))) +% W[r.i] +% s[r.i];
 
                 v[r.d] = v[r.d] +% v[r.h];
 

From ee241c47ee675050e4e4b0eabd6ba06a82cc626e Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Mon, 24 Oct 2022 00:38:10 -0700
Subject: [PATCH 65/70] std.crypto: SHA-256 Properly gate comptime conditional

This feature detection must be done at comptime so that we avoid
generating invalid ASM for the target.
---
 lib/std/crypto/sha2.zig | 144 +++++++++++++++++++++-------------------
 1 file changed, 74 insertions(+), 70 deletions(-)

diff --git a/lib/std/crypto/sha2.zig b/lib/std/crypto/sha2.zig
index d51c2e8cc7..5b2c8a89e1 100644
--- a/lib/std/crypto/sha2.zig
+++ b/lib/std/crypto/sha2.zig
@@ -192,85 +192,89 @@ fn Sha2x32(comptime params: Sha2Params32) type {
                 s[i] |= @as(u32, b[i * 4 + 3]) << 0;
             }
 
-            if (builtin.cpu.arch == .aarch64 and builtin.cpu.features.isEnabled(@enumToInt(std.Target.aarch64.Feature.sha2))) {
-                var x: v4u32 = d.s[0..4].*;
-                var y: v4u32 = d.s[4..8].*;
-                const s_v = @ptrCast(*[16]v4u32, &s);
+            switch (builtin.cpu.arch) {
+                .aarch64 => if (comptime builtin.cpu.features.isEnabled(@enumToInt(std.Target.aarch64.Feature.sha2))) {
+                    var x: v4u32 = d.s[0..4].*;
+                    var y: v4u32 = d.s[4..8].*;
+                    const s_v = @ptrCast(*[16]v4u32, &s);
 
-                comptime var k: u8 = 0;
-                inline while (k < 16) : (k += 1) {
-                    if (k > 3) {
-                        s_v[k] = asm (
-                            \\sha256su0.4s %[w0_3], %[w4_7]
-                            \\sha256su1.4s %[w0_3], %[w8_11], %[w12_15]
-                            : [w0_3] "=w" (-> v4u32),
-                            : [_] "0" (s_v[k - 4]),
-                              [w4_7] "w" (s_v[k - 3]),
-                              [w8_11] "w" (s_v[k - 2]),
-                              [w12_15] "w" (s_v[k - 1]),
+                    comptime var k: u8 = 0;
+                    inline while (k < 16) : (k += 1) {
+                        if (k > 3) {
+                            s_v[k] = asm (
+                                \\sha256su0.4s %[w0_3], %[w4_7]
+                                \\sha256su1.4s %[w0_3], %[w8_11], %[w12_15]
+                                : [w0_3] "=w" (-> v4u32),
+                                : [_] "0" (s_v[k - 4]),
+                                  [w4_7] "w" (s_v[k - 3]),
+                                  [w8_11] "w" (s_v[k - 2]),
+                                  [w12_15] "w" (s_v[k - 1]),
+                            );
+                        }
+
+                        const w: v4u32 = s_v[k] +% @as(v4u32, W[4 * k ..][0..4].*);
+                        asm volatile (
+                            \\mov.4s v0, %[x]
+                            \\sha256h.4s %[x], %[y], %[w]
+                            \\sha256h2.4s %[y], v0, %[w]
+                            : [x] "=w" (x),
+                              [y] "=w" (y),
+                            : [_] "0" (x),
+                              [_] "1" (y),
+                              [w] "w" (w),
+                            : "v0"
                         );
                     }
 
-                    const w: v4u32 = s_v[k] +% @as(v4u32, W[4 * k ..][0..4].*);
-                    asm volatile (
-                        \\mov.4s v0, %[x]
-                        \\sha256h.4s %[x], %[y], %[w]
-                        \\sha256h2.4s %[y], v0, %[w]
-                        : [x] "=w" (x),
-                          [y] "=w" (y),
-                        : [_] "0" (x),
-                          [_] "1" (y),
-                          [w] "w" (w),
-                        : "v0"
-                    );
-                }
+                    d.s[0..4].* = x +% @as(v4u32, d.s[0..4].*);
+                    d.s[4..8].* = y +% @as(v4u32, d.s[4..8].*);
+                    return;
+                },
+                .x86_64 => if (comptime builtin.cpu.features.isEnabled(@enumToInt(std.Target.x86.Feature.sha))) {
+                    var x: v4u32 = [_]u32{ d.s[5], d.s[4], d.s[1], d.s[0] };
+                    var y: v4u32 = [_]u32{ d.s[7], d.s[6], d.s[3], d.s[2] };
+                    const s_v = @ptrCast(*[16]v4u32, &s);
 
-                d.s[0..4].* = x +% @as(v4u32, d.s[0..4].*);
-                d.s[4..8].* = y +% @as(v4u32, d.s[4..8].*);
-                return;
-            } else if (builtin.cpu.arch == .x86_64 and builtin.cpu.features.isEnabled(@enumToInt(std.Target.x86.Feature.sha))) {
-                var x: v4u32 = [_]u32{ d.s[5], d.s[4], d.s[1], d.s[0] };
-                var y: v4u32 = [_]u32{ d.s[7], d.s[6], d.s[3], d.s[2] };
-                const s_v = @ptrCast(*[16]v4u32, &s);
+                    comptime var k: u8 = 0;
+                    inline while (k < 16) : (k += 1) {
+                        if (k < 12) {
+                            const r = asm ("sha256msg1 %[w4_7], %[w0_3]"
+                                : [w0_3] "=x" (-> v4u32),
+                                : [_] "0" (s_v[k]),
+                                  [w4_7] "x" (s_v[k + 1]),
+                            );
+                            const t = @shuffle(u32, s_v[k + 2], s_v[k + 3], [_]i32{ 1, 2, 3, -1 });
+                            s_v[k + 4] = asm ("sha256msg2 %[w12_15], %[t]"
+                                : [t] "=x" (-> v4u32),
+                                : [_] "0" (r +% t),
+                                  [w12_15] "x" (s_v[k + 3]),
+                            );
+                        }
 
-                comptime var k: u8 = 0;
-                inline while (k < 16) : (k += 1) {
-                    if (k < 12) {
-                        const r = asm ("sha256msg1 %[w4_7], %[w0_3]"
-                            : [w0_3] "=x" (-> v4u32),
-                            : [_] "0" (s_v[k]),
-                              [w4_7] "x" (s_v[k + 1]),
-                        );
-                        const t = @shuffle(u32, s_v[k + 2], s_v[k + 3], [_]i32{ 1, 2, 3, -1 });
-                        s_v[k + 4] = asm ("sha256msg2 %[w12_15], %[t]"
-                            : [t] "=x" (-> v4u32),
-                            : [_] "0" (r +% t),
-                              [w12_15] "x" (s_v[k + 3]),
+                        const w: v4u32 = s_v[k] +% @as(v4u32, W[4 * k ..][0..4].*);
+                        asm volatile (
+                            \\sha256rnds2 %[x], %[y]
+                            \\pshufd $0xe, %%xmm0, %%xmm0
+                            \\sha256rnds2 %[y], %[x]
+                            : [y] "=x" (y),
+                              [x] "=x" (x),
+                            : [_] "0" (y),
+                              [_] "1" (x),
+                              [_] "{xmm0}" (w),
                         );
                     }
 
-                    const w: v4u32 = s_v[k] +% @as(v4u32, W[4 * k ..][0..4].*);
-                    asm volatile (
-                        \\sha256rnds2 %[x], %[y]
-                        \\pshufd $0xe, %%xmm0, %%xmm0
-                        \\sha256rnds2 %[y], %[x]
-                        : [y] "=x" (y),
-                          [x] "=x" (x),
-                        : [_] "0" (y),
-                          [_] "1" (x),
-                          [_] "{xmm0}" (w),
-                    );
-                }
-
-                d.s[0] +%= x[3];
-                d.s[1] +%= x[2];
-                d.s[4] +%= x[1];
-                d.s[5] +%= x[0];
-                d.s[2] +%= y[3];
-                d.s[3] +%= y[2];
-                d.s[6] +%= y[1];
-                d.s[7] +%= y[0];
-                return;
+                    d.s[0] +%= x[3];
+                    d.s[1] +%= x[2];
+                    d.s[4] +%= x[1];
+                    d.s[5] +%= x[0];
+                    d.s[2] +%= y[3];
+                    d.s[3] +%= y[2];
+                    d.s[6] +%= y[1];
+                    d.s[7] +%= y[0];
+                    return;
+                },
+                else => {},
             }
 
             while (i < 64) : (i += 1) {

From 4c1f71e866088a1a2e943331256115ed7e3daf98 Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Mon, 24 Oct 2022 09:47:31 -0700
Subject: [PATCH 66/70] std.crypto: Optimize SHA-256 intrinsics for AMD x86-64

This gets us most of the way back to the performance I had when
I was using the LLVM intrinsics:
  - Intel Intel(R) Core(TM) i7-1068NG7 CPU @ 2.30GHz:
       190.67 MB/s (w/o intrinsics) -> 1285.08 MB/s
  - AMD EPYC 7763 (VM) @ 2.45 GHz:
       240.09 MB/s (w/o intrinsics) -> 1360.78 MB/s
  - Apple M1:
       216.96 MB/s (w/o intrinsics) -> 2133.69 MB/s

Minor changes to this source can swing performance from 400 MB/s to
1400 MB/s or... 20 MB/s, depending on how it interacts with the
optimizer. I have a sneaking suspicion that despite LLVM inheriting
GCC's extremely strict inline assembly semantics, its passes are
rather skittish around inline assembly (and almost certainly, its
instruction cost models can assume nothing)
---
 lib/std/crypto/sha2.zig | 46 ++++++++++++++++++++---------------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/lib/std/crypto/sha2.zig b/lib/std/crypto/sha2.zig
index 5b2c8a89e1..5380f32f0b 100644
--- a/lib/std/crypto/sha2.zig
+++ b/lib/std/crypto/sha2.zig
@@ -182,14 +182,8 @@ fn Sha2x32(comptime params: Sha2Params32) type {
 
         fn round(d: *Self, b: *const [64]u8) void {
             var s: [64]u32 align(16) = undefined;
-
-            var i: usize = 0;
-            while (i < 16) : (i += 1) {
-                s[i] = 0;
-                s[i] |= @as(u32, b[i * 4 + 0]) << 24;
-                s[i] |= @as(u32, b[i * 4 + 1]) << 16;
-                s[i] |= @as(u32, b[i * 4 + 2]) << 8;
-                s[i] |= @as(u32, b[i * 4 + 3]) << 0;
+            for (@ptrCast(*align(1) const [16]u32, b)) |*elem, i| {
+                s[i] = mem.readIntBig(u32, mem.asBytes(elem));
             }
 
             switch (builtin.cpu.arch) {
@@ -238,30 +232,35 @@ fn Sha2x32(comptime params: Sha2Params32) type {
                     comptime var k: u8 = 0;
                     inline while (k < 16) : (k += 1) {
                         if (k < 12) {
-                            const r = asm ("sha256msg1 %[w4_7], %[w0_3]"
-                                : [w0_3] "=x" (-> v4u32),
-                                : [_] "0" (s_v[k]),
+                            var tmp = s_v[k];
+                            s_v[k + 4] = asm (
+                                \\ sha256msg1 %[w4_7], %[tmp]
+                                \\ vpalignr $0x4, %[w8_11], %[w12_15], %[result]
+                                \\ paddd %[tmp], %[result]
+                                \\ sha256msg2 %[w12_15], %[result]
+                                : [tmp] "=&x" (tmp),
+                                  [result] "=&x" (-> v4u32),
+                                : [_] "0" (tmp),
                                   [w4_7] "x" (s_v[k + 1]),
-                            );
-                            const t = @shuffle(u32, s_v[k + 2], s_v[k + 3], [_]i32{ 1, 2, 3, -1 });
-                            s_v[k + 4] = asm ("sha256msg2 %[w12_15], %[t]"
-                                : [t] "=x" (-> v4u32),
-                                : [_] "0" (r +% t),
+                                  [w8_11] "x" (s_v[k + 2]),
                                   [w12_15] "x" (s_v[k + 3]),
                             );
                         }
 
                         const w: v4u32 = s_v[k] +% @as(v4u32, W[4 * k ..][0..4].*);
-                        asm volatile (
-                            \\sha256rnds2 %[x], %[y]
-                            \\pshufd $0xe, %%xmm0, %%xmm0
-                            \\sha256rnds2 %[y], %[x]
-                            : [y] "=x" (y),
-                              [x] "=x" (x),
+                        y = asm ("sha256rnds2 %[x], %[y]"
+                            : [y] "=x" (-> v4u32),
                             : [_] "0" (y),
-                              [_] "1" (x),
+                              [x] "x" (x),
                               [_] "{xmm0}" (w),
                         );
+
+                        x = asm ("sha256rnds2 %[y], %[x]"
+                            : [x] "=x" (-> v4u32),
+                            : [_] "0" (x),
+                              [y] "x" (y),
+                              [_] "{xmm0}" (@bitCast(v4u32, @bitCast(u128, w) >> 64)),
+                        );
                     }
 
                     d.s[0] +%= x[3];
@@ -277,6 +276,7 @@ fn Sha2x32(comptime params: Sha2Params32) type {
                 else => {},
             }
 
+            var i: usize = 16;
             while (i < 64) : (i += 1) {
                 s[i] = s[i - 16] +% s[i - 7] +% (math.rotr(u32, s[i - 15], @as(u32, 7)) ^ math.rotr(u32, s[i - 15], @as(u32, 18)) ^ (s[i - 15] >> 3)) +% (math.rotr(u32, s[i - 2], @as(u32, 17)) ^ math.rotr(u32, s[i - 2], @as(u32, 19)) ^ (s[i - 2] >> 10));
             }

From f9fe548e41a41e3edcff4d30f495246d0fee145b Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Fri, 28 Oct 2022 08:24:12 -0700
Subject: [PATCH 67/70] std.crypto: Add `isComptime` guard around intrinsics

Comptime code can't execute assembly code, so we need some way to
force comptime code to use the generic path. This should be replaced
with whatever is implemented for #868, when that day comes.

I am seeing that the result for the hash is incorrect in stage1 and
crashes stage2, so presumably this never worked correctly. I will follow
up on that soon.
---
 lib/std/crypto/sha2.zig | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/lib/std/crypto/sha2.zig b/lib/std/crypto/sha2.zig
index 5380f32f0b..510c22b14f 100644
--- a/lib/std/crypto/sha2.zig
+++ b/lib/std/crypto/sha2.zig
@@ -71,6 +71,12 @@ const Sha256Params = Sha2Params32{
 
 const v4u32 = @Vector(4, u32);
 
+// TODO: Remove once https://github.com/ziglang/zig/issues/868 is resolved.
+fn isComptime() bool {
+    var a: u8 = 0;
+    return @typeInfo(@TypeOf(.{a})).Struct.fields[0].is_comptime;
+}
+
 /// SHA-224
 pub const Sha224 = Sha2x32(Sha224Params);
 
@@ -187,7 +193,7 @@ fn Sha2x32(comptime params: Sha2Params32) type {
             }
 
             switch (builtin.cpu.arch) {
-                .aarch64 => if (comptime builtin.cpu.features.isEnabled(@enumToInt(std.Target.aarch64.Feature.sha2))) {
+                .aarch64 => if (!isComptime() and comptime builtin.cpu.features.isEnabled(@enumToInt(std.Target.aarch64.Feature.sha2))) {
                     var x: v4u32 = d.s[0..4].*;
                     var y: v4u32 = d.s[4..8].*;
                     const s_v = @ptrCast(*[16]v4u32, &s);
@@ -224,7 +230,7 @@ fn Sha2x32(comptime params: Sha2Params32) type {
                     d.s[4..8].* = y +% @as(v4u32, d.s[4..8].*);
                     return;
                 },
-                .x86_64 => if (comptime builtin.cpu.features.isEnabled(@enumToInt(std.Target.x86.Feature.sha))) {
+                .x86_64 => if (!isComptime() and comptime builtin.cpu.features.isEnabled(@enumToInt(std.Target.x86.Feature.sha))) {
                     var x: v4u32 = [_]u32{ d.s[5], d.s[4], d.s[1], d.s[0] };
                     var y: v4u32 = [_]u32{ d.s[7], d.s[6], d.s[3], d.s[2] };
                     const s_v = @ptrCast(*[16]v4u32, &s);

From 84e0c148b1d276d0dd60488c095dfb395372a216 Mon Sep 17 00:00:00 2001
From: Andrew Kelley <andrew@ziglang.org>
Date: Fri, 28 Oct 2022 15:30:04 -0700
Subject: [PATCH 68/70] CLI: report error when `-fstage1` requested but not
 available

---
 src/Compilation.zig | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Compilation.zig b/src/Compilation.zig
index 5c3db25555..be9e82cd87 100644
--- a/src/Compilation.zig
+++ b/src/Compilation.zig
@@ -1109,6 +1109,7 @@ pub fn create(gpa: Allocator, options: InitOptions) !*Compilation {
         const root_name = try arena.dupeZ(u8, options.root_name);
 
         const use_stage1 = options.use_stage1 orelse false;
+        if (use_stage1 and !build_options.have_stage1) return error.ZigCompilerBuiltWithoutStage1;
 
         // Make a decision on whether to use LLVM or our own backend.
         const use_llvm = build_options.have_llvm and blk: {

From 67fa3262b1329316cbf62e00ba3890d68a9f5f6d Mon Sep 17 00:00:00 2001
From: Cody Tapscott <topolarity@tapscott.me>
Date: Fri, 28 Oct 2022 17:17:08 -0700
Subject: [PATCH 69/70] std.crypto: Use `featureSetHas` to gate intrinsics

This also fixes a bug where the feature gating was not taking
effect at comptime due to https://github.com/ziglang/zig/issues/6768
---
 lib/std/crypto/sha2.zig | 160 ++++++++++++++++++++--------------------
 1 file changed, 81 insertions(+), 79 deletions(-)

diff --git a/lib/std/crypto/sha2.zig b/lib/std/crypto/sha2.zig
index 510c22b14f..9cdf8edcf1 100644
--- a/lib/std/crypto/sha2.zig
+++ b/lib/std/crypto/sha2.zig
@@ -192,94 +192,96 @@ fn Sha2x32(comptime params: Sha2Params32) type {
                 s[i] = mem.readIntBig(u32, mem.asBytes(elem));
             }
 
-            switch (builtin.cpu.arch) {
-                .aarch64 => if (!isComptime() and comptime builtin.cpu.features.isEnabled(@enumToInt(std.Target.aarch64.Feature.sha2))) {
-                    var x: v4u32 = d.s[0..4].*;
-                    var y: v4u32 = d.s[4..8].*;
-                    const s_v = @ptrCast(*[16]v4u32, &s);
+            if (!isComptime()) {
+                switch (builtin.cpu.arch) {
+                    .aarch64 => if (comptime std.Target.aarch64.featureSetHas(builtin.cpu.features, .sha2)) {
+                        var x: v4u32 = d.s[0..4].*;
+                        var y: v4u32 = d.s[4..8].*;
+                        const s_v = @ptrCast(*[16]v4u32, &s);
 
-                    comptime var k: u8 = 0;
-                    inline while (k < 16) : (k += 1) {
-                        if (k > 3) {
-                            s_v[k] = asm (
-                                \\sha256su0.4s %[w0_3], %[w4_7]
-                                \\sha256su1.4s %[w0_3], %[w8_11], %[w12_15]
-                                : [w0_3] "=w" (-> v4u32),
-                                : [_] "0" (s_v[k - 4]),
-                                  [w4_7] "w" (s_v[k - 3]),
-                                  [w8_11] "w" (s_v[k - 2]),
-                                  [w12_15] "w" (s_v[k - 1]),
+                        comptime var k: u8 = 0;
+                        inline while (k < 16) : (k += 1) {
+                            if (k > 3) {
+                                s_v[k] = asm (
+                                    \\sha256su0.4s %[w0_3], %[w4_7]
+                                    \\sha256su1.4s %[w0_3], %[w8_11], %[w12_15]
+                                    : [w0_3] "=w" (-> v4u32),
+                                    : [_] "0" (s_v[k - 4]),
+                                      [w4_7] "w" (s_v[k - 3]),
+                                      [w8_11] "w" (s_v[k - 2]),
+                                      [w12_15] "w" (s_v[k - 1]),
+                                );
+                            }
+
+                            const w: v4u32 = s_v[k] +% @as(v4u32, W[4 * k ..][0..4].*);
+                            asm volatile (
+                                \\mov.4s v0, %[x]
+                                \\sha256h.4s %[x], %[y], %[w]
+                                \\sha256h2.4s %[y], v0, %[w]
+                                : [x] "=w" (x),
+                                  [y] "=w" (y),
+                                : [_] "0" (x),
+                                  [_] "1" (y),
+                                  [w] "w" (w),
+                                : "v0"
                             );
                         }
 
-                        const w: v4u32 = s_v[k] +% @as(v4u32, W[4 * k ..][0..4].*);
-                        asm volatile (
-                            \\mov.4s v0, %[x]
-                            \\sha256h.4s %[x], %[y], %[w]
-                            \\sha256h2.4s %[y], v0, %[w]
-                            : [x] "=w" (x),
-                              [y] "=w" (y),
-                            : [_] "0" (x),
-                              [_] "1" (y),
-                              [w] "w" (w),
-                            : "v0"
-                        );
-                    }
+                        d.s[0..4].* = x +% @as(v4u32, d.s[0..4].*);
+                        d.s[4..8].* = y +% @as(v4u32, d.s[4..8].*);
+                        return;
+                    },
+                    .x86_64 => if (comptime std.Target.x86.featureSetHas(builtin.cpu.features, .sha)) {
+                        var x: v4u32 = [_]u32{ d.s[5], d.s[4], d.s[1], d.s[0] };
+                        var y: v4u32 = [_]u32{ d.s[7], d.s[6], d.s[3], d.s[2] };
+                        const s_v = @ptrCast(*[16]v4u32, &s);
 
-                    d.s[0..4].* = x +% @as(v4u32, d.s[0..4].*);
-                    d.s[4..8].* = y +% @as(v4u32, d.s[4..8].*);
-                    return;
-                },
-                .x86_64 => if (!isComptime() and comptime builtin.cpu.features.isEnabled(@enumToInt(std.Target.x86.Feature.sha))) {
-                    var x: v4u32 = [_]u32{ d.s[5], d.s[4], d.s[1], d.s[0] };
-                    var y: v4u32 = [_]u32{ d.s[7], d.s[6], d.s[3], d.s[2] };
-                    const s_v = @ptrCast(*[16]v4u32, &s);
+                        comptime var k: u8 = 0;
+                        inline while (k < 16) : (k += 1) {
+                            if (k < 12) {
+                                var tmp = s_v[k];
+                                s_v[k + 4] = asm (
+                                    \\ sha256msg1 %[w4_7], %[tmp]
+                                    \\ vpalignr $0x4, %[w8_11], %[w12_15], %[result]
+                                    \\ paddd %[tmp], %[result]
+                                    \\ sha256msg2 %[w12_15], %[result]
+                                    : [tmp] "=&x" (tmp),
+                                      [result] "=&x" (-> v4u32),
+                                    : [_] "0" (tmp),
+                                      [w4_7] "x" (s_v[k + 1]),
+                                      [w8_11] "x" (s_v[k + 2]),
+                                      [w12_15] "x" (s_v[k + 3]),
+                                );
+                            }
 
-                    comptime var k: u8 = 0;
-                    inline while (k < 16) : (k += 1) {
-                        if (k < 12) {
-                            var tmp = s_v[k];
-                            s_v[k + 4] = asm (
-                                \\ sha256msg1 %[w4_7], %[tmp]
-                                \\ vpalignr $0x4, %[w8_11], %[w12_15], %[result]
-                                \\ paddd %[tmp], %[result]
-                                \\ sha256msg2 %[w12_15], %[result]
-                                : [tmp] "=&x" (tmp),
-                                  [result] "=&x" (-> v4u32),
-                                : [_] "0" (tmp),
-                                  [w4_7] "x" (s_v[k + 1]),
-                                  [w8_11] "x" (s_v[k + 2]),
-                                  [w12_15] "x" (s_v[k + 3]),
+                            const w: v4u32 = s_v[k] +% @as(v4u32, W[4 * k ..][0..4].*);
+                            y = asm ("sha256rnds2 %[x], %[y]"
+                                : [y] "=x" (-> v4u32),
+                                : [_] "0" (y),
+                                  [x] "x" (x),
+                                  [_] "{xmm0}" (w),
+                            );
+
+                            x = asm ("sha256rnds2 %[y], %[x]"
+                                : [x] "=x" (-> v4u32),
+                                : [_] "0" (x),
+                                  [y] "x" (y),
+                                  [_] "{xmm0}" (@bitCast(v4u32, @bitCast(u128, w) >> 64)),
                             );
                         }
 
-                        const w: v4u32 = s_v[k] +% @as(v4u32, W[4 * k ..][0..4].*);
-                        y = asm ("sha256rnds2 %[x], %[y]"
-                            : [y] "=x" (-> v4u32),
-                            : [_] "0" (y),
-                              [x] "x" (x),
-                              [_] "{xmm0}" (w),
-                        );
-
-                        x = asm ("sha256rnds2 %[y], %[x]"
-                            : [x] "=x" (-> v4u32),
-                            : [_] "0" (x),
-                              [y] "x" (y),
-                              [_] "{xmm0}" (@bitCast(v4u32, @bitCast(u128, w) >> 64)),
-                        );
-                    }
-
-                    d.s[0] +%= x[3];
-                    d.s[1] +%= x[2];
-                    d.s[4] +%= x[1];
-                    d.s[5] +%= x[0];
-                    d.s[2] +%= y[3];
-                    d.s[3] +%= y[2];
-                    d.s[6] +%= y[1];
-                    d.s[7] +%= y[0];
-                    return;
-                },
-                else => {},
+                        d.s[0] +%= x[3];
+                        d.s[1] +%= x[2];
+                        d.s[4] +%= x[1];
+                        d.s[5] +%= x[0];
+                        d.s[2] +%= y[3];
+                        d.s[3] +%= y[2];
+                        d.s[6] +%= y[1];
+                        d.s[7] +%= y[0];
+                        return;
+                    },
+                    else => {},
+                }
             }
 
             var i: usize = 16;

From c66d3f6bf6be62d565a444792390655f4db3bd7a Mon Sep 17 00:00:00 2001
From: Zhora Trush <tensorush@gmail.com>
Date: Tue, 18 Oct 2022 14:49:09 +0200
Subject: [PATCH 70/70] Enhance indexOfIgnoreCase with Boyer-Moore-Horspool
 algorithm

---
 lib/std/ascii.zig | 53 +++++++++++++++++++++++++++++++++++++++--------
 lib/std/mem.zig   | 13 ++++++------
 2 files changed, 51 insertions(+), 15 deletions(-)

diff --git a/lib/std/ascii.zig b/lib/std/ascii.zig
index cd8b14e98f..eac3ba0565 100644
--- a/lib/std/ascii.zig
+++ b/lib/std/ascii.zig
@@ -555,22 +555,54 @@ test "ascii.endsWithIgnoreCase" {
     try std.testing.expect(!endsWithIgnoreCase("BoB", "Bo"));
 }
 
-/// Finds `substr` in `container`, ignoring case, starting at `start_index`.
-/// TODO boyer-moore algorithm
-pub fn indexOfIgnoreCasePos(container: []const u8, start_index: usize, substr: []const u8) ?usize {
-    if (substr.len > container.len) return null;
+/// Finds `needle` in `haystack`, ignoring case, starting at index 0.
+pub fn indexOfIgnoreCase(haystack: []const u8, needle: []const u8) ?usize {
+    return indexOfIgnoreCasePos(haystack, 0, needle);
+}
+
+/// Finds `needle` in `haystack`, ignoring case, starting at `start_index`.
+/// Uses Boyer-Moore-Horspool algorithm on large inputs; `indexOfIgnoreCasePosLinear` on small inputs.
+pub fn indexOfIgnoreCasePos(haystack: []const u8, start_index: usize, needle: []const u8) ?usize {
+    if (needle.len > haystack.len) return null;
+    if (needle.len == 0) return start_index;
+
+    if (haystack.len < 52 or needle.len <= 4)
+        return indexOfIgnoreCasePosLinear(haystack, start_index, needle);
+
+    var skip_table: [256]usize = undefined;
+    boyerMooreHorspoolPreprocessIgnoreCase(needle, skip_table[0..]);
 
     var i: usize = start_index;
-    const end = container.len - substr.len;
+    while (i <= haystack.len - needle.len) {
+        if (eqlIgnoreCase(haystack[i .. i + needle.len], needle)) return i;
+        i += skip_table[toLower(haystack[i + needle.len - 1])];
+    }
+
+    return null;
+}
+
+/// Consider using `indexOfIgnoreCasePos` instead of this, which will automatically use a
+/// more sophisticated algorithm on larger inputs.
+pub fn indexOfIgnoreCasePosLinear(haystack: []const u8, start_index: usize, needle: []const u8) ?usize {
+    var i: usize = start_index;
+    const end = haystack.len - needle.len;
     while (i <= end) : (i += 1) {
-        if (eqlIgnoreCase(container[i .. i + substr.len], substr)) return i;
+        if (eqlIgnoreCase(haystack[i .. i + needle.len], needle)) return i;
     }
     return null;
 }
 
-/// Finds `substr` in `container`, ignoring case, starting at index 0.
-pub fn indexOfIgnoreCase(container: []const u8, substr: []const u8) ?usize {
-    return indexOfIgnoreCasePos(container, 0, substr);
+fn boyerMooreHorspoolPreprocessIgnoreCase(pattern: []const u8, table: *[256]usize) void {
+    for (table) |*c| {
+        c.* = pattern.len;
+    }
+
+    var i: usize = 0;
+    // The last item is intentionally ignored and the skip size will be pattern.len.
+    // This is the standard way Boyer-Moore-Horspool is implemented.
+    while (i < pattern.len - 1) : (i += 1) {
+        table[toLower(pattern[i])] = pattern.len - 1 - i;
+    }
 }
 
 test "indexOfIgnoreCase" {
@@ -579,6 +611,9 @@ test "indexOfIgnoreCase" {
     try std.testing.expect(indexOfIgnoreCase("foO", "Foo").? == 0);
     try std.testing.expect(indexOfIgnoreCase("foo", "fool") == null);
     try std.testing.expect(indexOfIgnoreCase("FOO foo", "fOo").? == 0);
+
+    try std.testing.expect(indexOfIgnoreCase("one two three four five six seven eight nine ten eleven", "ThReE fOUr").? == 8);
+    try std.testing.expect(indexOfIgnoreCase("one two three four five six seven eight nine ten eleven", "Two tWo") == null);
 }
 
 /// Returns the lexicographical order of two slices. O(n).
diff --git a/lib/std/mem.zig b/lib/std/mem.zig
index 4000030fc0..d43ba70477 100644
--- a/lib/std/mem.zig
+++ b/lib/std/mem.zig
@@ -1083,7 +1083,7 @@ fn boyerMooreHorspoolPreprocessReverse(pattern: []const u8, table: *[256]usize)
 
     var i: usize = pattern.len - 1;
     // The first item is intentionally ignored and the skip size will be pattern.len.
-    // This is the standard way boyer-moore-horspool is implemented.
+    // This is the standard way Boyer-Moore-Horspool is implemented.
     while (i > 0) : (i -= 1) {
         table[pattern[i]] = i;
     }
@@ -1096,14 +1096,15 @@ fn boyerMooreHorspoolPreprocess(pattern: []const u8, table: *[256]usize) void {
 
     var i: usize = 0;
     // The last item is intentionally ignored and the skip size will be pattern.len.
-    // This is the standard way boyer-moore-horspool is implemented.
+    // This is the standard way Boyer-Moore-Horspool is implemented.
     while (i < pattern.len - 1) : (i += 1) {
         table[pattern[i]] = pattern.len - 1 - i;
     }
 }
+
 /// Find the index in a slice of a sub-slice, searching from the end backwards.
 /// To start looking at a different index, slice the haystack first.
-/// Uses the Reverse boyer-moore-horspool algorithm on large inputs;
+/// Uses the Reverse Boyer-Moore-Horspool algorithm on large inputs;
 /// `lastIndexOfLinear` on small inputs.
 pub fn lastIndexOf(comptime T: type, haystack: []const T, needle: []const T) ?usize {
     if (needle.len > haystack.len) return null;
@@ -1131,7 +1132,7 @@ pub fn lastIndexOf(comptime T: type, haystack: []const T, needle: []const T) ?us
     return null;
 }
 
-/// Uses Boyer-moore-horspool algorithm on large inputs; `indexOfPosLinear` on small inputs.
+/// Uses Boyer-Moore-Horspool algorithm on large inputs; `indexOfPosLinear` on small inputs.
 pub fn indexOfPos(comptime T: type, haystack: []const T, start_index: usize, needle: []const T) ?usize {
     if (needle.len > haystack.len) return null;
     if (needle.len == 0) return start_index;
@@ -1183,7 +1184,7 @@ test "indexOf" {
 
 test "indexOf multibyte" {
     {
-        // make haystack and needle long enough to trigger boyer-moore-horspool algorithm
+        // make haystack and needle long enough to trigger Boyer-Moore-Horspool algorithm
         const haystack = [1]u16{0} ** 100 ++ [_]u16{ 0xbbaa, 0xccbb, 0xddcc, 0xeedd, 0xffee, 0x00ff };
         const needle = [_]u16{ 0xbbaa, 0xccbb, 0xddcc, 0xeedd, 0xffee };
         try testing.expectEqual(indexOfPos(u16, &haystack, 0, &needle), 100);
@@ -1196,7 +1197,7 @@ test "indexOf multibyte" {
     }
 
     {
-        // make haystack and needle long enough to trigger boyer-moore-horspool algorithm
+        // make haystack and needle long enough to trigger Boyer-Moore-Horspool algorithm
         const haystack = [_]u16{ 0xbbaa, 0xccbb, 0xddcc, 0xeedd, 0xffee, 0x00ff } ++ [1]u16{0} ** 100;
         const needle = [_]u16{ 0xbbaa, 0xccbb, 0xddcc, 0xeedd, 0xffee };
         try testing.expectEqual(lastIndexOf(u16, &haystack, &needle), 0);